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 "F1SetupResponse.h"
  28 #include "SuccessfulOutcome.h"
  29 #include "InitiatingMessage.h"
  30 #include "NonDynamic5QIDescriptor.h"
  31 #include "AveragingWindow.h"
  32 #include "MaxDataBurstVolume.h"
  33 #include "Flows-Mapped-To-DRB-Item.h"
  34 #include "SliceSupportItem.h"
  35 #include "ServedPLMNs-Item.h"
  36 #include "F1AP-PDU.h"
  37 #include "ULUPTNLInformation-ToBeSetup-Item.h"
  38 #include "ULConfiguration.h"
  39 #include "ModulationOrder.h"
  40 #include "BandNR.h"
  41 #include "UE-CapabilityRAT-Container.h"
  42 #include "UE-CapabilityRAT-ContainerList.h"
  43 #include "UE-CapabilityRAT-ContainerListRRC.h"
  44 #include "HandoverPreparationInformationRrc-IEs.h"
  45 #include "HandoverPreparationInformationRrc.h"
  46 #include "SupportedBandwidth.h"
  47 #include "FeatureSetUplinkPerCC.h"
  48 #include "FeatureSetDownlinkPerCC.h"
  49 #include "FeatureSets.h"
  50 #include "RF-Parameters.h"
  51 #include "UE-NR-Capability.h"
  52 #include "ProtocolExtensionContainer.h"
  53 #include "CellGroupConfigRrc.h"
  54 #include "MAC-CellGroupConfig.h"
  55 #include "SchedulingRequestConfig.h"
  56 #include "SchedulingRequestToAddMod.h"
  57 #include "BSR-Config.h"
  58 #include "TAG-Config.h"
  59 #include "TAG.h"
  60 #include "PHR-Config.h"
  61 #include "RLC-Config.h"
  62 #include "UL-AM-RLC.h"
  63 #include "DL-AM-RLC.h"
  64 #include "LogicalChannelConfig.h"
  65 #include "RLC-BearerConfig.h"
  66 #include "PhysicalCellGroupConfig.h"
  67 #include "SpCellConfig.h"
  68 #include "ServingCellConfig.h"
  69 #include "ControlResourceSet.h"
  70 #include "SearchSpace.h"
  71 #include "PDCCH-Config.h"
  72 #include "PDSCH-TimeDomainResourceAllocation.h"
  73 #include "PDSCH-TimeDomainResourceAllocationList.h"
  74 #include "DMRS-DownlinkConfig.h"
  75 #include "PDSCH-Config.h"
  76 #include "BWP-DownlinkDedicated.h"
  77 #include "PUSCH-TimeDomainResourceAllocation.h"
  78 #include "PUSCH-TimeDomainResourceAllocationList.h"
  79 #include "DMRS-UplinkConfig.h"
  80 #include "PUSCH-Config.h"
  81 #include "SRS-ResourceId.h"
  82 #include "SRS-Resource.h"
  83 #include "SRS-ResourceSet.h"
  84 #include "SRS-Config.h"
  85 #include "PUCCH-Config.h"
  86 #include "PUCCH-ResourceSet.h"
  87 #include "PUCCH-Resource.h"
  88 #include "PUCCH-format1.h"
  89 #include "PUCCH-FormatConfig.h"
  90 #include "BWP-UplinkDedicated.h"
  91 #include "PUSCH-ServingCellConfig.h"
  92 #include "UplinkConfig.h"
  93 #include "PDSCH-ServingCellConfig.h"
  94 #include "EUTRANQoS.h"
  95 #include "GBR-QosInformation.h"
  96 #include "DRBs-ToBeSetupMod-List.h"
  97 #include "DRBs-ToBeSetupMod-Item.h"
  98 #include "DRBs-Setup-Item.h"
  99 #include "DLUPTNLInformation-ToBeSetup-List.h"
 100 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 101 #include "UPTransportLayerInformation.h"
 102 #include "GTPTunnel.h"
 103 #include "QoSInformation.h"
 104 #include "Cells-to-be-Activated-List.h"
 105 #include "DL-CCCH-Message.h"
 106 #include "SRB-ToAddModList.h"
 107 #include "SRB-ToAddMod.h"
 108 #include "RRCSetup-IEs.h"
 109 #include "RRCSetup.h"
 110 #include "DL-DCCH-Message.h"
 111 #include "RRCReconfiguration-IEs.h"
 112 #include "RRCReconfiguration.h"
 113 #include "DRB-ToAddModList.h"
 114 #include "DRB-ToAddMod.h"
 115 #include "SDAP-Config.h"
 116 #include "SSB-MTC.h"
 117 #include "MeasTiming.h"
 118 #include "MeasTimingList.h"
 119 #include "MeasurementTimingConfigurationRrc-IEs.h"
 120 #include "MeasurementTimingConfigurationRrc.h"
 121 #include "PDCP-Config.h"
 122 #include "RSRP-Range.h"
 123 #include "RSRQ-Range.h"
 124 #include "SINR-Range.h"
 125 #include "ThresholdNR.h"
 126 #include "MeasObjectToAddMod.h"
 127 #include "MeasObjectNR.h"
 128 #include "MeasObjectToAddModList.h"
 129 #include "EventTriggerConfig.h"
 130 #include "ReportConfigNR.h"
 131 #include "ReportConfigToAddMod.h"
 132 #include "ReportConfigToAddModList.h"
 133 #include "MeasIdToAddMod.h"
 134 #include "MeasIdToAddModList.h"
 135 #include "FilterCoefficient.h"
 136 #include "QuantityConfigNR.h"
 137 #include "QuantityConfig.h"
 138 #include "MeasConfigRrc.h"
 139 #include "AS-Config.h"
 140 #include "RRCReconfiguration-v1530-IEs.h"
 141 #include "CNUEPagingIdentity.h"
 142 #include "PagingCell-Item.h"
 143 #include "UL-DCCH-Message.h"
 144 #include "DRX-ConfigRrc.h"
 145
 146 #include "cu_stub_sctp.h"
 147 #include "cu_stub_egtp.h"
 148 #include "cu_f1ap_msg_hdl.h"
 149 #include "cu_stub.h"
 150
 151 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 152 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 153
 154 /*******************************************************************
 155  *
 156  * @brief Sends F1 msg over SCTP
 157  *
 158  * @details
 159  *
 160  *    Function : SendF1APMsg
 161  *
 162  *    Functionality: Sends F1 msg over SCTP
 163  *
 164  * @params[in] Region region
 165  *             Pool pool
 166  * @return ROK     - success
 167  *         RFAILED - failure
 168  *
 169  * ****************************************************************/
 170 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 171 {
 172    Buffer *mBuf = NULLP;
 173
 174    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 175    {
 176       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 177       {
 178          ODU_PRINT_MSG(mBuf, 0,0);
 179
 180          if(sctpSend(duId, mBuf) != ROK)
 181          {
 182             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 183             ODU_PUT_MSG_BUF(mBuf);
 184             return RFAILED;
 185          }
 186       }
 187       else
 188       {
 189          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 190          ODU_PUT_MSG_BUF(mBuf);
 191          return RFAILED;
 192       }
 193       ODU_PUT_MSG_BUF(mBuf);
 194    }
 195    else
 196    {
 197       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 198       return RFAILED;
 199    }
 200
 201    return ROK;
 202 } /* SendF1APMsg */
 203
 204 /********************************************************************
 205  *
 206  * @brief Builds and sends the F1SetupResponse
 207  *
 208  * @details
 209  *
 210  *    Function : BuildAndSendF1SetupRsp
 211  *
 212  *    Functionality: Constructs the F1SetupResponse message and sends
 213  *                   it back to the DU through SCTP.
 214  *
 215  * @params[in] void **buf,Buffer to which encoded pattern is written into
 216  * @params[in] int *size,size of buffer
 217  *
 218  * @return ROK     - success
 219  *         RFAILED - failure
 220  *
 221  * ****************************************************************/
 222 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 223 {
 224    uint8_t    idx,ieIdx;
 225    uint8_t    elementCnt,cellCnt;
 226    F1AP_PDU_t         *f1apMsg = NULL;
 227    F1SetupResponse_t  *f1SetupRsp;
 228    GNB_CU_Name_t      *cuName;
 229    Cells_to_be_Activated_List_t *cellToActivate;
 230    RRC_Version_t      *rrcVer;
 231    asn_enc_rval_t     encRetVal;
 232    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 233
 234    /* Allocate the memory for F1SetupRequest_t */
 235    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 236    if(f1apMsg == NULLP)
 237    {
 238       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 239       return RFAILED;
 240    }
 241    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 242
 243    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 244    if(f1apMsg->choice.successfulOutcome == NULLP)
 245    {
 246       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 247       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 248       return RFAILED;
 249    }
 250
 251    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 252    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 253    f1apMsg->choice.successfulOutcome->value.present = \
 254                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 255    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 256
 257    elementCnt = 4;
 258    f1SetupRsp->protocolIEs.list.count = elementCnt;
 259    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 260
 261    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 262          elementCnt * sizeof(F1SetupResponseIEs_t *));
 263    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 264    {
 265       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 266       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 267       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 268       return RFAILED;
 269    }
 270
 271    for(idx=0; idx<elementCnt; idx++)
 272    {
 273       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 274             sizeof(F1SetupResponseIEs_t));
 275       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 276       {
 277          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 278                elementCnt * sizeof(F1SetupResponseIEs_t *));
 279          CU_FREE(f1apMsg->choice.successfulOutcome, \
 280                sizeof(SuccessfulOutcome_t));
 281          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 282          return RFAILED;
 283       }
 284    }
 285
 286    /*TransactionID*/
 287    idx = 0;
 288    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 289    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 290    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 291                                                             F1SetupResponseIEs__value_PR_TransactionID;
 292    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 293                                                                         TRANS_ID;
 294
 295    /*CU Name*/
 296    idx++;
 297    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 298    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 299    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 300                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 301    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 302    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 303
 304    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 305    if(cuName->buf == NULLP)
 306    {
 307       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 308       {
 309          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 310                sizeof(F1SetupResponseIEs_t));
 311       }
 312       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 313             elementCnt * sizeof(F1SetupResponseIEs_t *));
 314       CU_FREE(f1apMsg->choice.successfulOutcome,\
 315             sizeof(SuccessfulOutcome_t));
 316       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 317       return RFAILED;
 318    }
 319    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 320
 321    /*Cells to be activated list*/
 322    idx++;
 323    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 324                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 325    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 326    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 327                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 328    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 329                     Cells_to_be_Activated_List;
 330    cellCnt=1;
 331    cellToActivate->list.count = cellCnt;
 332    cellToActivate->list.size = \
 333                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 334    CU_ALLOC(cellToActivate->list.array,\
 335          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 336    if(cellToActivate->list.array == NULLP)
 337    {
 338       CU_FREE(cuName->buf, sizeof(cuName->size));
 339       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 340       {
 341          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 342                sizeof(F1SetupResponseIEs_t));
 343       }
 344       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 345             elementCnt * sizeof(F1SetupResponseIEs_t *));
 346       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 347       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 348       return RFAILED;
 349    }
 350    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 351    {
 352       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 353       if(cellToActivate->list.array[ieIdx] == NULLP)
 354       {
 355          CU_FREE(cellToActivate->list.array,\
 356                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 357          CU_FREE(cuName->buf, sizeof(cuName->size));
 358          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 359          {
 360             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 361                   sizeof(F1SetupResponseIEs_t));
 362          }
 363          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 364                elementCnt * sizeof(F1SetupResponseIEs_t *));
 365          CU_FREE(f1apMsg->choice.successfulOutcome, \
 366                sizeof(SuccessfulOutcome_t));
 367          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 368          return RFAILED;
 369       }
 370    }
 371    cellToActivate->list.array[0]->id = \
 372                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 373    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 374    cellToActivate->list.array[0]->value.present = \
 375                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 376    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 377       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 378    CU_ALLOC(cellToActivate->list.array[0]->\
 379          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 380          3*sizeof(uint8_t));
 381    if(cellToActivate->list.array[0]->value.choice.\
 382          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 383    {
 384
 385       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 386       {
 387          CU_FREE(cellToActivate->list.array[ieIdx],\
 388                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 389       }
 390
 391       CU_FREE(cellToActivate->list.array,\
 392             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 393       CU_FREE(cuName->buf, sizeof(cuName->size));
 394       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 395       {
 396          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 397                sizeof(F1SetupResponseIEs_t));
 398       }
 399       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 400             elementCnt * sizeof(F1SetupResponseIEs_t *));
 401       CU_FREE(f1apMsg->choice.successfulOutcome, \
 402             sizeof(SuccessfulOutcome_t));
 403       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 404       return RFAILED;
 405    }
 406    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 407          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 408    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 409       nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
 410    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 411          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 412          cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 413          nRCGI.nRCellIdentity.size);
 414    if(cellToActivate->list.array[0]->value.choice.\
 415          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 416    {
 417       CU_FREE(cellToActivate->list.array[0]->\
 418             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 419             3*sizeof(uint8_t));
 420       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 421       {
 422          CU_FREE(cellToActivate->list.array[ieIdx],\
 423                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 424       }
 425
 426       CU_FREE(cellToActivate->list.array,\
 427             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 428       CU_FREE(cuName->buf, sizeof(cuName->size));
 429       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 430       {
 431          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 432                sizeof(F1SetupResponseIEs_t));
 433       }
 434       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 435             elementCnt * sizeof(F1SetupResponseIEs_t *));
 436       CU_FREE(f1apMsg->choice.successfulOutcome, \
 437             sizeof(SuccessfulOutcome_t));
 438       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 439       return RFAILED;
 440    }
 441    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 442    /* RRC Version */
 443    idx++;
 444    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 445                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 446    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 447    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 448                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 449    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 450    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 451
 452    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 453    if(rrcVer->latest_RRC_Version.buf == NULLP)
 454    {
 455       CU_FREE(cuName->buf, sizeof(cuName->size));
 456       for(ieIdx=0; ieIdx<elementCnt; idx++)
 457       {
 458          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 459                sizeof(F1SetupResponseIEs_t));
 460       }
 461       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 462             elementCnt * sizeof(F1SetupResponseIEs_t *));
 463       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 464       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 465       return RFAILED;
 466    }
 467
 468    /* Need to check RRC Version */
 469    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 470    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 471    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 472    if(rrcVer->iE_Extensions == NULLP)
 473    {
 474       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 475       CU_FREE(cuName->buf, sizeof(cuName->size));
 476       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 477       {
 478          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 479                sizeof(F1SetupResponseIEs_t));
 480       }
 481       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 482             elementCnt * sizeof(F1SetupResponseIEs_t *));
 483       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 484       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 485       return RFAILED;
 486    }
 487    rrcVer->iE_Extensions->list.count = 1;
 488    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 489    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 490          sizeof(struct RRC_Version_ExtIEs *));
 491    if(rrcVer->iE_Extensions->list.array == NULLP)
 492    {
 493       CU_FREE(rrcVer->iE_Extensions,\
 494             sizeof(ProtocolExtensionContainer_4624P81_t));
 495       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 496       CU_FREE(cuName->buf, sizeof(cuName->size));
 497       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 498       {
 499          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 500                sizeof(F1SetupResponseIEs_t));
 501       }
 502       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 503             elementCnt * sizeof(F1SetupResponseIEs_t *));
 504       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 505       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 506       return RFAILED;
 507    }
 508    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 509          sizeof(struct RRC_Version_ExtIEs));
 510    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 511    {
 512       CU_FREE(rrcVer->iE_Extensions->list.array,\
 513             sizeof(struct RRC_Version_ExtIEs *));
 514       CU_FREE(rrcVer->iE_Extensions,\
 515             sizeof(ProtocolExtensionContainer_4624P81_t));
 516       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 517       CU_FREE(cuName->buf, sizeof(cuName->size));
 518       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 519       {
 520          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 521                sizeof(F1SetupResponseIEs_t));
 522       }
 523       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 524             elementCnt * sizeof(F1SetupResponseIEs_t *));
 525       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 526       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 527       return RFAILED;
 528    }
 529    rrcVer->iE_Extensions->list.array[0]->id = \
 530                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 531    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 532    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 533                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 534    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 535       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 536    CU_ALLOC(rrcVer->iE_Extensions->list.\
 537          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 538          3*sizeof(uint8_t));
 539    if(rrcVer->iE_Extensions->list.\
 540          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 541    {
 542       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 543             sizeof(struct RRC_Version_ExtIEs));
 544       CU_FREE(rrcVer->iE_Extensions->list.array,\
 545             sizeof(struct RRC_Version_ExtIEs *));
 546       CU_FREE(rrcVer->iE_Extensions,\
 547             sizeof(ProtocolExtensionContainer_4624P81_t));
 548       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 549       CU_FREE(cuName->buf, sizeof(cuName->size));
 550       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 551       {
 552          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 553                sizeof(F1SetupResponseIEs_t));
 554       }
 555       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 556             elementCnt * sizeof(F1SetupResponseIEs_t *));
 557       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 558       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 559       return RFAILED;
 560    }
 561    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 562       Latest_RRC_Version_Enhanced.buf[0] = 0;
 563    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 564       Latest_RRC_Version_Enhanced.buf[1] = 5;
 565    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 566       Latest_RRC_Version_Enhanced.buf[2] = 15;
 567
 568    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 569
 570    /* Encode the F1SetupRequest type as UPER */
 571    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 572    encBufSize = 0;
 573    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 574
 575    /* Clean up */
 576    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 577    CU_FREE(cuName->buf, sizeof(cuName->size));
 578    for(idx=0; idx<elementCnt; idx++)
 579    {
 580       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 581    }
 582    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 583    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 584    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 585
 586    /* Check encode results */
 587    if(encRetVal.encoded == ENCODE_FAIL)
 588    {
 589       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 590             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 591       return RFAILED;
 592    }
 593    else
 594    {
 595       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 596       for(int i=0; i< encBufSize; i++)
 597       {
 598          DU_LOG("%x",encBuf[i]);
 599       }
 600    }
 601
 602    /* Sending msg */
 603    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 604    {
 605       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 606       return RFAILED;
 607    }
 608
 609    return ROK;
 610 }/* End of BuildAndSendF1SetupRsp */
 611
 612 /*******************************************************************
 613  *
 614  * @brief Builds and sends the DUUpdateAcknowledge
 615  *
 616  * @details
 617  *
 618  *    Function : BuildAndSendDUUpdateAck
 619  *
 620  *    Functionality: Constructs the DU Update Acknowledge message and sends
 621  *                   it to the DU through SCTP.
 622  *
 623  * @params[in]
 624  *
 625  * @return ROK     - success
 626  *         RFAILED - failure
 627  *
 628  * ****************************************************************/
 629
 630 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 631 {
 632    uint8_t   idx;
 633    uint8_t   elementCnt;
 634    F1AP_PDU_t *f1apMsg = NULL;
 635    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 636    asn_enc_rval_t enRetVal; /* Encoder return value */
 637
 638    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 639
 640    /* Allocate the memory for F1SetupRequest_t */
 641    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 642    if(f1apMsg == NULLP)
 643    {
 644       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 645       return RFAILED;
 646    }
 647
 648    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 649
 650    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 651    if(f1apMsg->choice.successfulOutcome == NULLP)
 652    {
 653       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 654       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 655       return RFAILED;
 656    }
 657
 658    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 659    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 660    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 661    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 662
 663    elementCnt = 1;
 664    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 665    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 666
 667    /* Initialize the F1Setup members */
 668    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 669    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 670    {
 671       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 672       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 673       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 674       return RFAILED;
 675    }
 676
 677    for(idx=0; idx<elementCnt; idx++)
 678    {
 679       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 680       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 681       {
 682          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 683          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 684          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 685          return RFAILED;
 686       }
 687    }
 688
 689    /*TransactionID*/
 690    idx = 0;
 691    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 692    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 693    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 694    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 695    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 696
 697    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 698
 699    /* Encode the F1SetupRequest type as UPER */
 700    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 701    encBufSize = 0;
 702    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 703
 704    /* Clean up */
 705    for(idx=0; idx<elementCnt; idx++)
 706    {
 707       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 708    }
 709    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 710    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 711    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 712
 713    /* Checking encode results */
 714    if(enRetVal.encoded == ENCODE_FAIL)
 715    {
 716       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 717       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 718       return RFAILED;
 719    }
 720    else
 721    {
 722       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 723       for(int i=0; i< encBufSize; i++)
 724       {
 725          DU_LOG("%x",encBuf[i]);
 726       }
 727    }
 728
 729    /* Sending msg */
 730    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 731    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 732    {
 733       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 734       return RFAILED;
 735    }
 736
 737    return ROK;
 738
 739 }/* End of BuildAndSendDUUpdateAck*/
 740
 741 /*******************************************************************
 742 *
 743 * @brief deallocating the memory of  F1reset msg
 744 *
 745 * @details
 746 *
 747 *    Function : FreeF1ResetReq
 748 *
 749 *    Functionality :
 750 *         - freeing memory of F1reset request msg
 751 *
 752 * @params[in]
 753 * @return void
 754 *
 755 *
 756 * ****************************************************************/
 757 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 758 {
 759    uint8_t idx = 0;
 760    Reset_t *f1ResetMsg = NULLP;
 761
 762    if(f1apMsg)
 763    {
 764       if(f1apMsg->choice.initiatingMessage)
 765       {
 766          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 767          if(f1ResetMsg->protocolIEs.list.array)
 768          {
 769             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 770             {
 771                if(f1ResetMsg->protocolIEs.list.array[idx])
 772                {
 773                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 774                }
 775             }
 776             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 777          }
 778          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 779       }
 780       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 781    }
 782 }
 783 /*******************************************************************
 784  *
 785  * @brief build ansld ans send f1reset msg
 786  *
 787  * @details
 788  *
 789  *    Function : BuildAndSendF1ResetReq
 790  *
 791  *    Functionality: build and send f1reset msg
 792  *
 793  * @return ROK     - success
 794  *         RFAILED - failure
 795  *
 796  * ****************************************************************/
 797 uint8_t BuildAndSendF1ResetReq()
 798 {
 799    uint8_t          elementCnt=0;
 800    uint8_t          idx=0;
 801    uint8_t          ret= RFAILED;
 802    Reset_t          *f1ResetMsg = NULLP;
 803    F1AP_PDU_t       *f1apMsg = NULLP;
 804    asn_enc_rval_t   encRetVal;
 805    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 806    do
 807    {
 808       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 809       if(f1apMsg == NULLP)
 810       {
 811          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 812          break;
 813       }
 814       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 815       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 816       if(f1apMsg->choice.initiatingMessage == NULLP)
 817       {
 818          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 819          break;
 820       }
 821       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 822       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 823       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 824
 825       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 826
 827       elementCnt = 3;
 828       f1ResetMsg->protocolIEs.list.count = elementCnt;
 829       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 830
 831       /* Initialize the F1Reset members */
 832       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 833       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 834       {
 835          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 836          break;
 837       }
 838       for(idx=0; idx<elementCnt; idx++)
 839       {
 840          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 841          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 842          {
 843             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 844             break;
 845          }
 846       }
 847
 848       /*TransactionID*/
 849       idx=0;
 850       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 851       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 852       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 853       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 854
 855       /*Cause*/
 856       idx++;
 857       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 858       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 859       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 860       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 861       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 862
 863       /*Reset Type*/
 864       idx++;
 865       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 866       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 867       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 868       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 869       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 870
 871       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 872
 873       /* Encode the F1SetupRequest type as APER */
 874       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 875       encBufSize = 0;
 876       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 877             encBuf);
 878
 879       /* Encode results */
 880       if(encRetVal.encoded == ENCODE_FAIL)
 881       {
 882          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 883                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 884          break;
 885       }
 886       else
 887       {
 888          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 889          for(idx=0; idx< encBufSize; idx++)
 890          {
 891             DU_LOG("%x",encBuf[idx]);
 892          }
 893       }
 894
 895       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 896       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 897       {
 898          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 899          break;
 900       }
 901
 902       ret = ROK;
 903       break;
 904    }while(true);
 905
 906    FreeF1ResetReq(f1apMsg);
 907    return ret;
 908 }
 909
 910 /*******************************************************************
 911  *
 912  * @brief Fills Radio Bearer Config
 913  *
 914  * @details
 915  *
 916  *    Function : fillSrbCfg
 917  *
 918  *    Functionality: Fills Radio Bearer Config
 919  *
 920  * @params[in] SRB_ToAddModList *
 921  *
 922  * @return ROK     - success
 923  *         RFAILED - failure
 924  *
 925  * ****************************************************************/
 926 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 927 {
 928    uint8_t elementCnt = 0;
 929    uint8_t idx, ieId, srbIdx = 0;
 930
 931    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 932    {
 933       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 934          elementCnt++;
 935    }
 936
 937    if(bearerCfg != NULLP)
 938    {
 939       bearerCfg->list.count = elementCnt;
 940       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 941       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 942       if(bearerCfg->list.array != NULLP)
 943       {
 944          for(idx = 0; idx < elementCnt; idx++)
 945          {
 946             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 947             if(bearerCfg->list.array[idx] == NULLP)
 948             {
 949                for(ieId = 0; ieId < idx; ieId++)
 950                {
 951                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 952                }
 953                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 954                return RFAILED;
 955             }
 956          }
 957       }
 958       else
 959       {
 960          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 961          return RFAILED;
 962       }
 963
 964       idx = 0;
 965       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 966       {
 967          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 968             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 969       }
 970    }
 971    return ROK;
 972 }
 973
 974 /*******************************************************************
 975  *
 976  * @brief Fills Master CellGroup Info
 977  *
 978  * @details
 979  *
 980  *    Function : fillMasterCellGroup
 981  *
 982  *    Functionality: Fills Master Cell Group IE
 983  *
 984  * @params[in] RRCSetup_IEs_t *
 985  *
 986  * @return ROK     - success
 987  *         RFAILED - failure
 988  *
 989  * ****************************************************************/
 990
 991 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 992 {
 993    uint8_t ret = ROK;
 994    masterCellGroup->buf = NULLP;
 995    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 996    {
 997       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 998       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 999       if(masterCellGroup->buf != NULLP)
1000       {
1001          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
1002       }
1003       else
1004       {
1005          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
1006          ret = RFAILED;
1007       }
1008    }
1009    else
1010    {
1011       ret =  RFAILED;
1012    }
1013    return ret;
1014 }
1015
1016 /*******************************************************************
1017  *
1018  * @brief Fills RRC setup IE
1019  *
1020  * @details
1021  *
1022  *    Function : fillRRCSetupIE
1023  *
1024  *    Functionality: Fills RRC Setup IE
1025  *
1026  * @params[in] RRCSetup_IEs_t *
1027  *
1028  * @return ROK     - success
1029  *         RFAILED - failure
1030  *
1031  * ****************************************************************/
1032
1033 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1034 {
1035    uint8_t ret = ROK, srbIdx = 0;
1036    if(rrcSetupIE)
1037    {
1038       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1039       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1040       {
1041          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1042       }
1043       if(ret == ROK)
1044       {
1045          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1046       }
1047       else
1048       {
1049          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1050          ret = RFAILED;
1051       }
1052
1053       /* If SRB configuration are filled successfully in RRC Setup, mark these
1054        * configurartion as sent to UE */
1055       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1056       {
1057          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1058             ueCb->srbList[srbIdx].cfgSentToUe = true;
1059       }
1060    }
1061    return ret;
1062 }
1063 /*******************************************************************
1064  *
1065  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1066  *
1067  * @details
1068  *
1069  *    Function : fillDlCcchRrcMsg
1070  *
1071  *    Functionality: Fills DL DCCCH Message required for
1072  *                   DLRRCMessageTransfer
1073  *
1074  * @params[in] RRCContainer_t *rrcContainer
1075  *
1076  * @return ROK     - success
1077  *         RFAILED - failure
1078  *
1079  * ****************************************************************/
1080
1081 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1082 {
1083    uint8_t ret = ROK;
1084    uint16_t idx2;
1085    DL_CCCH_Message_t dl_CCCH_Msg;
1086    asn_enc_rval_t    encRetVal;
1087
1088    if(rrcContainer != NULLP)
1089    {
1090       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1091
1092       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1093       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1094       {
1095          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1096          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1097          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1098          {
1099             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1100             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1101                RRCSetup__criticalExtensions_PR_rrcSetup;
1102
1103             /* Fill RRC Setup IE */
1104             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1105                sizeof(RRCSetup_IEs_t));
1106             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1107             {
1108                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1109
1110                if(ret == ROK)
1111                {
1112                   /* encode DL-CCCH message into RRC Container */
1113                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1114                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1115                   encBufSize = 0;
1116                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1117                   /* Encode results */
1118                   if(encRetVal.encoded == ENCODE_FAIL)
1119                   {
1120                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1121                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1122                      return RFAILED;
1123                   }
1124                   else
1125                   {
1126                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1127                      for(int i = 0; i< encBufSize; i++)
1128                      {
1129                         DU_LOG("%x",encBuf[i]);
1130                      }
1131                      rrcContainer->size = encBufSize;
1132                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1133                      if(rrcContainer->buf != NULLP)
1134                      {
1135                         memset(rrcContainer->buf, 0, encBufSize);
1136                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1137                         {
1138                            rrcContainer->buf[idx2] =    encBuf[idx2];
1139                         }
1140                      }
1141                   }
1142                }
1143                else
1144                {
1145                   ret = RFAILED;
1146                }
1147             }
1148             else
1149             {
1150                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1151                ret = RFAILED;
1152             }
1153          }
1154          else
1155          {
1156             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1157             ret = RFAILED;
1158          }
1159       }
1160       else
1161       {
1162          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1163          ret = RFAILED;
1164       }
1165    }
1166    else
1167    {
1168       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1169       ret = RFAILED;
1170    }
1171 }
1172
1173 /*******************************************************************
1174  *
1175  * @brief Fills QOS flow configuration
1176  *
1177  * @details
1178  *
1179  *    Function : fillQosFlowsToAdd
1180  *
1181  *    Functionality: Fills QOS flow configuration
1182  *
1183  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1184  *
1185  * @return ROK     - success
1186  *         RFAILED - failure
1187  *
1188  * ****************************************************************/
1189 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1190 {
1191    uint8_t idx, ied, elementCnt;
1192
1193    elementCnt = 1;
1194    qosFlow->list.count = elementCnt;
1195    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1196    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1197    if(qosFlow->list.array != NULLP)
1198    {
1199       for(idx = 0; idx < elementCnt; idx++)
1200       {
1201          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1202          if(qosFlow->list.array[idx] == NULLP)
1203          {
1204             for(ied = 0; ied < idx; ied++)
1205             {
1206                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1207             }
1208             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1209             return RFAILED;
1210          }
1211       }
1212    }
1213    idx = 0;
1214    *qosFlow->list.array[idx] = 9;
1215    return ROK;
1216 }
1217
1218 /*******************************************************************
1219  *
1220  * @brief Fills CN Assoc for Drb to Add/Mod List
1221  *
1222  * @details
1223  *
1224  *    Function : fillCnAssoc
1225  *
1226  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1227  *
1228  * @params[in] struct DRB_ToAddMod__cnAssociation *
1229  *
1230  * @return ROK     - success
1231  *         RFAILED - failure
1232  *
1233  * ****************************************************************/
1234
1235 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1236 {
1237    uint8_t ret = ROK;
1238
1239    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1240    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1241    {
1242       cnAssoc->choice.eps_BearerIdentity = 5;
1243    }
1244    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1245    {
1246       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1247       if(cnAssoc->choice.sdap_Config)
1248       {
1249          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1250          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1251          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1252          cnAssoc->choice.sdap_Config->defaultDRB = true;
1253          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1254          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1255          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1256                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1257          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1258          {
1259             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1260          }
1261          else
1262          {
1263             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1264             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1265             ret = RFAILED;
1266          }
1267       }
1268       else
1269       {
1270          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1271          ret = RFAILED;
1272       }
1273    }
1274    return ret;
1275 }
1276
1277 /*******************************************************************
1278  *
1279  * @brief Fills Radio Bearer Config for Drb
1280  *
1281  * @details
1282  *
1283  *    Function : fillDrbCfg
1284  *
1285  *    Functionality: Fills Radio Bearer Config for Drb
1286  *
1287  * @params[in] drbId, DRB_ToAddModList *
1288  *
1289  * @return ROK     - success
1290  *         RFAILED - failure
1291  *
1292  * ****************************************************************/
1293 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1294 {
1295    uint8_t idx, ied, ret, elementCnt;
1296
1297    ret = ROK;
1298    if(drbCfg != NULLP)
1299    {
1300       elementCnt = 1;
1301       drbCfg->list.count = elementCnt;
1302       drbCfg->list.size =\
1303                          elementCnt * sizeof(DRB_ToAddMod_t *);
1304       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1305       if(drbCfg->list.array != NULLP)
1306       {
1307          for(idx = 0; idx < elementCnt; idx++)
1308          {
1309             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1310             if(drbCfg->list.array[idx] == NULLP)
1311             {
1312                for(ied = 0; ied < idx; ied++)
1313                {
1314                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1315                }
1316                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1317                return RFAILED;
1318             }
1319          }
1320       }
1321       else
1322       {
1323          return RFAILED;
1324       }
1325       idx = 0;
1326       /* CN ASSOCIATION */
1327       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1328       if(drbCfg->list.array[idx]->cnAssociation)
1329       {
1330          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1331       }
1332       /* DRB */
1333       drbCfg->list.array[idx]->drb_Identity = drbId;
1334    }
1335    return ret;
1336 }
1337
1338 /*******************************************************************
1339  *
1340  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1341  *
1342  * @details
1343  *
1344  *    Function : fillRrcReconfigIE
1345  *
1346  *    Functionality: Fills RRC Reconfig Message required for
1347  *                   DLRRCMessageTransfer
1348  *
1349  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1350  *
1351  * @return ROK     - success
1352  *         RFAILED - failure
1353  *
1354  * ****************************************************************/
1355
1356 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1357 {
1358    uint8_t ret = ROK;
1359    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1360    if(rrcReconfigMsg->radioBearerConfig)
1361    {
1362       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1363       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1364       {
1365          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1366
1367       }
1368       if(ret == ROK)
1369       {
1370          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1371          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1372          {
1373             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1374             if(ret == RFAILED)
1375             {
1376                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1377                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1378                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1379             }
1380          }
1381       }
1382       else
1383       {
1384          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1385          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1386       }
1387    }
1388
1389    return ret;
1390 }
1391 /*******************************************************************
1392  *
1393  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1394  *
1395  * @details
1396  *
1397  *    Function : fillDlDcchRrcMsg
1398  *
1399  *    Functionality: Fills DL DCCH Message required for
1400  *                   DLRRCMessageTransfer
1401  *
1402  * @params[in] RRCContainer_t *rrcContainer
1403  *
1404  * @return ROK     - success
1405  *         RFAILED - failure
1406  *
1407  * ****************************************************************/
1408
1409 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1410 {
1411    uint8_t ret = ROK;
1412    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1413    DL_DCCH_Message_t dl_DCCH_Msg;
1414    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1415    asn_enc_rval_t        encRetVal;
1416
1417    if(rrcContainer != NULLP)
1418    {
1419       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1420
1421       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1422       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1423       {
1424          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1425          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1426          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1427          {
1428             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1429             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1430             if(ret == ROK)
1431             {
1432                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1433                 * configurartion as sent to UE */
1434                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1435                {
1436                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1437                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1438                }
1439                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1440                {
1441                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1442                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1443                }
1444
1445                /* encode DL-DCCH message into RRC Container */
1446                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1447                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1448                encBufSize = 0;
1449                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1450                /* Encode results */
1451                if(encRetVal.encoded == ENCODE_FAIL)
1452                {
1453                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1454                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1455                   return RFAILED;
1456                }
1457                else
1458                {
1459                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1460                   for(int i = 0; i< encBufSize; i++)
1461                   {
1462                      DU_LOG("%x",encBuf[i]);
1463                   }
1464                   rrcContainer->size = encBufSize;
1465                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1466                   if(rrcContainer->buf != NULLP)
1467                   {
1468                      memset(rrcContainer->buf, 0, encBufSize);
1469                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1470                      {
1471                         rrcContainer->buf[idx2] =       encBuf[idx2];
1472                      }
1473                   }
1474                }
1475             }
1476          }
1477          else
1478          {
1479             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1480             ret = RFAILED;
1481          }
1482       }
1483       else
1484       {
1485          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1486          ret = RFAILED;
1487       }
1488    }
1489    else
1490    {
1491       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1492       ret = RFAILED;
1493    }
1494    return ret;
1495 }
1496
1497 /*******************************************************************
1498  *
1499  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1500  *
1501  * @details
1502  *
1503  *    Function : BuildDLRRCContainer
1504  *
1505  *    Functionality: Builds RRC Container IE required for
1506  *                   DLRRCMessageTransfer
1507  *
1508  * @params[in]
1509  *
1510  * @return ROK     - success
1511  *         RFAILED - failure
1512  *
1513  * ****************************************************************/
1514
1515 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1516 {
1517    uint8_t ret, bufLen;
1518
1519    ret =ROK;
1520    if(rrcMsgType == RRC_SETUP)
1521    {
1522       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1523       if(ret == RFAILED)
1524          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1525    }
1526    else if(rrcMsgType == RRC_SETUP_COMPLETE)
1527    {
1528       DU_LOG("\nINFO --> F1AP : Sending NAS Security mode command");
1529       char secModeBuf[30]={0x00, 0x02, 0x2e, 0x82, 0xaf, 0xc0, 0x7d, 0x1c, 0x4e, 0xfc, 0x80, 0x0f, 0xc0,
1530                           0x0b, 0xa0, 0x20, 0x40, 0x9e, 0x0e, 0x1e, 0x0e, 0x1c, 0x26, 0xc0, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00};
1531       bufLen =30;
1532       rrcContainer->size = bufLen;
1533       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1534       if(rrcContainer->buf != NULLP)
1535       {
1536          memset(rrcContainer->buf, 0, bufLen);
1537          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1538       }
1539       else
1540       {
1541          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1542          ret = RFAILED;
1543       }
1544    }
1545    else if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
1546    {
1547       DU_LOG("\nINFO --> F1AP : Sending RRC Security mode command");
1548       char secModeBuf[9]={0x00, 0x03, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1549       bufLen =9;
1550       rrcContainer->size = bufLen;
1551       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1552       if(rrcContainer->buf != NULLP)
1553       {
1554          memset(rrcContainer->buf, 0, bufLen);
1555          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1556       }
1557       else
1558       {
1559          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1560          ret = RFAILED;
1561       }
1562    }
1563    else if(rrcMsgType == RRC_SECURITY_MODE_COMPLETE)
1564    {
1565       /*Hardcoded RRC Container from reference logs*/
1566       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1567       char buf[14] ={0x00, 0x04, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1568       bufLen =14;
1569       rrcContainer->size = bufLen;
1570       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1571       if(rrcContainer->buf != NULLP)
1572       {
1573          memset(rrcContainer->buf, 0, bufLen);
1574          memcpy(rrcContainer->buf, buf, bufLen);
1575       }
1576       else
1577       {
1578          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1579          ret = RFAILED;
1580       }
1581    }
1582    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1583    {
1584       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1585       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1586       if(ret == RFAILED)
1587          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1588    }
1589
1590    return ret;
1591 }
1592
1593 /*******************************************************************
1594  *
1595  * @brief Frees the DLRRCMessageTransfer
1596  *
1597  * @details
1598  *
1599  *    Function : freeDlRrcMessageTransfer
1600  *
1601  *    Functionality: Frees the DLRRCMessageTransfer
1602  *
1603  * @params[in]
1604  *
1605  * @return ROK     - success
1606  *         RFAILED - failure
1607  *
1608  * ****************************************************************/
1609 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1610 {
1611    uint8_t idx=0;
1612    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1613
1614    if(f1apMsg)
1615    {
1616       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1617       if(dlRRCMsg->protocolIEs.list.array)
1618       {
1619          idx = 3;
1620          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1621             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1622          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1623          {
1624             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1625          }
1626          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1627       }
1628       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1629    }
1630 }
1631
1632 /*******************************************************************
1633  *
1634  * @brief Builds and sends the DLRRCMessageTransfer
1635  *
1636  * @details
1637  *
1638  *    Function : BuildAndSendDLRRCMessageTransfer
1639  *
1640  *    Functionality: Constructs the DL RRC Message Transfer and sends
1641  *                   it to the CU through SCTP.
1642  *
1643  * @params[in]
1644  *
1645  * @return ROK     - success
1646  *         RFAILED - failure
1647  *
1648  * ****************************************************************/
1649 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1650 {
1651    uint8_t   elementCnt = 0;
1652    uint8_t  ieId;
1653    uint8_t  idx;
1654    F1AP_PDU_t  *f1apMsg = NULLP;
1655    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1656    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1657
1658    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1659
1660    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1661    if(f1apMsg == NULLP)
1662    {
1663       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1664       return RFAILED;
1665    }
1666
1667    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1668    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1669    if(f1apMsg->choice.initiatingMessage == NULLP)
1670    {
1671       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1672       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1673       return RFAILED;
1674    }
1675
1676    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1677    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1678    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1679    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1680
1681    elementCnt = 4;
1682    dlRRCMsg->protocolIEs.list.count = elementCnt;
1683    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1684
1685    /* Initialize the F1Setup members */
1686    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1687    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1688    {
1689       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1690       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1691       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1692       return RFAILED;
1693    }
1694
1695    for(idx=0; idx<elementCnt; idx++)
1696    {
1697       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1698       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1699       {
1700          for(ieId=0; ieId<idx; ieId++)
1701          {
1702             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1703          }
1704          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1705          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1706          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1707          return RFAILED;
1708       }
1709    }
1710
1711    /* GNB CU UE F1AP ID */
1712    idx = 0;
1713    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1714    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1715    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1716    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1717
1718    /* GNB DU UE F1AP ID */
1719    idx++;
1720    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1721    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1722    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1723    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1724
1725    /* SRBID */
1726    idx++;
1727    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1728    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1729    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1730    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1731
1732    /* RRCContainer */
1733    idx++;
1734    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1735    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1736    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1737    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1738
1739    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1740
1741    /* Encode the F1SetupRequest type as APER */
1742    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1743    encBufSize = 0;
1744    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1745          encBuf);
1746    /* Encode results */
1747    if(encRetVal.encoded == ENCODE_FAIL)
1748    {
1749       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1750             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1751       return RFAILED;
1752    }
1753    else
1754    {
1755       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1756       for(int i=0; i< encBufSize; i++)
1757       {
1758          DU_LOG("%x",encBuf[i]);
1759       }
1760    }
1761
1762    /* Sending  msg  */
1763    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1764    {
1765       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1766       return RFAILED;
1767    }
1768    freeDlRrcMessageTransfer(f1apMsg);
1769    return ROK;
1770 }/* End of BuildAndSendDLRRCMessageTransfer */
1771
1772 /*******************************************************************
1773  *
1774  * @brief Function to set the Dl RRC Msg Type
1775  *
1776  * @details
1777  *
1778  *    Function : setDlRRCMsgType
1779  *
1780  *    Functionality: Constructs the UE Setup Response and sends
1781  *                   it to the DU through SCTP.
1782  *
1783  * @params[in]
1784  *
1785  * @return ROK     - success
1786  *         RFAILED - failure
1787  *
1788  * ****************************************************************/
1789
1790 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1791 {
1792    uint8_t rrcMsgType = 0;
1793    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1794    {
1795       case RRC_SETUP:
1796          rrcMsgType = RRC_SETUP;
1797          break;
1798       case RRC_SETUP_COMPLETE:
1799          rrcMsgType = RRC_SETUP_COMPLETE;
1800          break;
1801       case NAS_SECURITY_MODE_COMPLETE:
1802          rrcMsgType = NAS_SECURITY_MODE_COMPLETE;
1803          break;
1804       case RRC_SECURITY_MODE_COMPLETE:
1805          rrcMsgType = RRC_SECURITY_MODE_COMPLETE;
1806          break;
1807       case REGISTRATION_COMPLETE:
1808          rrcMsgType = REGISTRATION_COMPLETE;
1809          break;
1810       case UE_CONTEXT_SETUP_RSP:
1811          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1812          break;
1813       case RRC_RECONFIG_COMPLETE:
1814          rrcMsgType = RRC_RECONFIG_COMPLETE;
1815          break;
1816       default:
1817          break;
1818    }
1819    return rrcMsgType;
1820 }
1821
1822 #ifdef NR_DRX
1823 /*******************************************************************
1824  *
1825  * @brief fill long cycle offset value of drx
1826  *
1827  * @details
1828  *
1829  *    Function : fillLongCycleOffsetValue
1830  *
1831  *    Functionality: fill long cycle offset value of drx
1832  *
1833  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
1834  * struct DRX_ConfigRrc__drx_LongCycleStartOffset recvedLongCycleOffsetVal
1835  *
1836  * @return ROK     - success
1837  *         RFAILED - failure
1838  *
1839  * ****************************************************************/
1840 void fillLongCycleOffsetValue(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset *recvedLongCycleOffsetVal)
1841 {
1842
1843    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = recvedLongCycleOffsetVal->present;
1844    switch(recvedLongCycleOffsetVal->present)
1845    {
1846       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
1847          {
1848             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10;
1849             break;
1850          }
1851       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
1852          {
1853             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms20;
1854             break;
1855          }
1856       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
1857          {
1858             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms32;
1859             break;
1860          }
1861       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
1862          {
1863             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms40;
1864             break;
1865          }
1866       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
1867          {
1868             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms60;
1869             break;
1870          }
1871       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
1872          {
1873             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms64;
1874             break;
1875          }
1876       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
1877          {
1878             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms70;
1879             break;
1880          }
1881       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
1882          {
1883             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms80;
1884             break;
1885          }
1886       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
1887          {
1888             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms128;
1889             break;
1890          }
1891       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
1892          {
1893             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms160;
1894             break;
1895          }
1896       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
1897          {
1898             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms256;
1899             break;
1900          }
1901       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
1902          {
1903             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms320;
1904             break;
1905          }
1906       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
1907          {
1908             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms512;
1909             break;
1910          }
1911       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
1912          {
1913             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms640;
1914             break;
1915          }
1916       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
1917          {
1918             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1024;
1919             break;
1920          }
1921       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
1922          {
1923             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1280;
1924             break;
1925          }
1926       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
1927          {
1928             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2048;
1929             break;
1930          }
1931       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
1932          {
1933             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2560;
1934             break;
1935          }
1936       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
1937          {
1938             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms5120;
1939             break;
1940          }
1941       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
1942          {
1943             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10240;
1944             break;
1945          }
1946       default :
1947          break;
1948    }
1949 }
1950
1951 /*******************************************************************
1952  *
1953  * @brief Extract configuration from DRX_ConfigRrc
1954  *    and store the drx configuration in UeCb
1955  *
1956  * @details
1957  *
1958  *    Function : storeDrxCfgInUeCb
1959  *
1960  *    Functionality: Store drx configuration in UeCb
1961  *
1962  * @params[in] (struct DRX_ConfigRrc *setup, DrxCfg *drxCfg)
1963  *
1964  * @return void
1965  * ****************************************************************/
1966 void storeDrxCfgInUeCb(struct DRX_ConfigRrc *drxSetup, DrxCfg *drxCfg)
1967 {
1968    if(drxSetup)
1969    {
1970       switch(drxSetup->drx_onDurationTimer.present)
1971       {
1972          case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
1973             break;
1974          case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
1975             {
1976                drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
1977                drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=drxSetup->drx_onDurationTimer.choice.milliSeconds;
1978                break;
1979             }
1980          case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
1981             {
1982                drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
1983                drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = drxSetup->drx_onDurationTimer.choice.subMilliSeconds;
1984                break;
1985             }
1986       }
1987    }
1988    fillLongCycleOffsetValue(&drxCfg->drxLongCycleStartOffset, &drxSetup->drx_LongCycleStartOffset);
1989    drxCfg->drxInactivityTimer = drxSetup->drx_InactivityTimer;
1990    drxCfg->drxHarqRttTimerDl = drxSetup->drx_HARQ_RTT_TimerDL;
1991    drxCfg->drxHarqRttTimerUl = drxSetup->drx_HARQ_RTT_TimerUL;
1992    drxCfg->drxRetransmissionTimerDl = drxSetup->drx_RetransmissionTimerDL;
1993    drxCfg->drxRetransmissionTimerUl = drxSetup->drx_RetransmissionTimerUL;
1994    drxCfg->drxSlotOffset = drxSetup->drx_SlotOffset;
1995    if(drxSetup->shortDRX)
1996    {
1997       drxCfg->shortDrxPres=true;
1998       drxCfg->shortDrx.drxShortCycle = drxSetup->shortDRX->drx_ShortCycle;
1999       drxCfg->shortDrx.drxShortCycleTimer = drxSetup->shortDRX->drx_ShortCycleTimer;
2000    }
2001    else
2002       drxCfg->shortDrxPres=false;
2003 }
2004 #endif
2005
2006 /*******************************************************************
2007  *
2008  * @brief Extract configuration from CellGroupConfig
2009  *
2010  * @details
2011  *
2012  *    Function : extractCellGroupConfig
2013  *
2014  *    Functionality: Extract configuration from CellGroupConfig
2015  *        and store in local database
2016  *
2017  * @params[in] UE control block
2018  *             Cell Group Config
2019  *
2020  * @return ROK     - success
2021  *         RFAILED - failure
2022  *
2023  * ****************************************************************/
2024 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
2025 {
2026    uint8_t rbIdx, srbIdx, drbIdx;
2027    bool    srbFound, drbFound;
2028    SrbInfo *srbCfgDb = NULLP;
2029    DrbInfo *drbCfgDb = NULLP;
2030    RlcLcCfg *rlcLcCfgDb = NULLP;
2031    MacLcCfg *macLcCfgDb = NULLP;
2032    RLC_BearerConfig_t *rlcCfg = NULLP;
2033    RLC_Config_t *rlcLcCfg = NULLP;
2034    LogicalChannelConfig_t *macLcCfg = NULLP;
2035 #ifdef NR_DRX
2036    DrxCfg    drxCfg;
2037 #endif
2038
2039    if(ueCb == NULLP)
2040    {
2041       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
2042       return RFAILED;
2043    }
2044
2045    if(cellGrpCfg == NULLP)
2046    {
2047       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
2048       return RFAILED;
2049    }
2050
2051 #ifdef NR_DRX
2052    if(cellGrpCfg->mac_CellGroupConfig)
2053    {
2054       if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc)
2055       {
2056          switch(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->present)
2057          {
2058             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
2059                break;
2060
2061             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
2062             {
2063                storeDrxCfgInUeCb(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup, &ueCb->drxCfg);
2064                break;
2065             }
2066
2067             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
2068                break;
2069          }
2070       }
2071    }
2072 #endif
2073
2074    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
2075    {
2076       srbFound = false;
2077       drbFound = false;
2078
2079       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
2080
2081       /* Update SRB configuration in local DB */
2082       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
2083       {
2084          /* Search if SRB entry is already present in DB */
2085          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
2086          {
2087             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
2088             {
2089               srbCfgDb = &ueCb->srbList[srbIdx];
2090               srbFound = true;
2091               break;
2092             }
2093          }
2094
2095          /* If not, add SRB to UE CB's SRB list */
2096          if(!srbFound)
2097          {
2098             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
2099             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
2100             ueCb->numSrb++;
2101          }
2102
2103          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2104          srbCfgDb->cfgSentToUe = false;
2105          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
2106          macLcCfgDb = &srbCfgDb->macLcCfg;
2107       }
2108
2109       /* Update DRB configuration in local DB */
2110       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
2111       {
2112          /* Search if DRB entry is already present in DB */
2113          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
2114          {
2115             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
2116             {
2117               drbCfgDb = &ueCb->drbList[drbIdx];
2118               drbFound = true;
2119               break;
2120             }
2121          }
2122
2123          /* If not, add DRB to UE CB's SRB list */
2124          if(!drbFound)
2125          {
2126             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
2127             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
2128             ueCb->numDrb++;
2129          }
2130
2131          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2132          drbCfgDb->cfgSentToUe = false;
2133          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
2134          macLcCfgDb = &drbCfgDb->macLcCfg;
2135       }
2136
2137
2138       /* Update RLC configuration for this RB */
2139       rlcLcCfg = rlcCfg->rlc_Config;
2140       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
2141       switch(rlcLcCfgDb->rlcMode)
2142       {
2143          case RLC_Config_PR_am:
2144             {
2145                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
2146                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
2147                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
2148                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
2149                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
2150
2151                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
2152                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
2153                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
2154                break;
2155             }
2156
2157          case RLC_Config_PR_um_Bi_Directional:
2158             {
2159                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
2160
2161                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
2162                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
2163                break;
2164             }
2165       }
2166
2167       /* Update MAC configuration for this LC */
2168       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
2169       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
2170       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
2171       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
2172       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
2173       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
2174    }
2175    return ROK;
2176 }
2177
2178 /*******************************************************************
2179  *
2180  * @brief Function to decode DU to CU RRC container
2181  *
2182  * @details
2183  *
2184  *    Function : extractDuToCuRrcCont
2185  *
2186  *    Functionality: Function to decode DU to CU RRC container
2187  *
2188  * @params[in] UE Cb
2189  *             RRC conatiner octect string to be decoded
2190  *
2191  * @return ROK     - success
2192  *         RFAILED - failure
2193  *
2194  * ****************************************************************/
2195 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
2196 {
2197    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
2198    asn_dec_rval_t rval; /* Decoder return value */
2199
2200    /* Copy the received container to UeCb */
2201    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
2202
2203    /* Decoding DU to CU RRC container octet string to cell group config */
2204    cellGrpCfgMsg = &cellGrpCfg;
2205    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
2206
2207    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
2208
2209    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2210    {
2211       DU_LOG("\nERROR  -->  F1AP : ASN decode failed in extractDuToCuRrcCont");
2212       return RFAILED;
2213    }
2214    printf("\n");
2215    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
2216
2217    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
2218    {
2219       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
2220       return RFAILED;
2221    }
2222
2223    return ROK;
2224 }
2225
2226 /*******************************************************************
2227  *
2228  * @brief Function to build Initial UL RRC Message
2229  *
2230  * @details
2231  *
2232  *    Function : procInitULRRCMsg
2233  *
2234  *    Functionality: Function to build Initial UL RRC Message
2235  *
2236  * @params[in]
2237  *
2238  * @return ROK     - success
2239  *         RFAILED - failure
2240  *
2241  * ****************************************************************/
2242
2243 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2244 {
2245    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2246    uint8_t ret =ROK;
2247    uint16_t cellIdx=0, nrCellId = 0;
2248    uint32_t crnti;
2249    DuDb     *duDb;
2250    CuCellCb *cellCb;
2251    CuUeCb   *ueCb;
2252    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2253
2254    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2255
2256    SEARCH_DU_DB(duIdx, duId, duDb);
2257    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2258
2259    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2260    {
2261       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2262       {
2263          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2264             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2265             break;
2266
2267          case ProtocolIE_ID_id_NRCGI:
2268             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2269             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2270             if(cellCb == NULLP)
2271                return RFAILED;
2272             break;
2273
2274          case ProtocolIE_ID_id_C_RNTI:
2275             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2276             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2277             {
2278                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2279                memset(ueCb, 0, sizeof(CuUeCb));
2280                ueCb->cellCb = cellCb;
2281                ueCb->crnti = crnti;
2282                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2283                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2284                ueCb->state = UE_ATTACH_IN_PROGRESS;
2285                (duDb->numUe)++;
2286
2287                cellCb->ueCb[cellCb->numUe] = ueCb;
2288                cellCb->numUe++;
2289             }
2290             break;
2291
2292          case ProtocolIE_ID_id_RRCContainer:
2293             break;
2294
2295          case ProtocolIE_ID_id_DUtoCURRCContainer:
2296             {
2297                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2298                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2299                {
2300                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2301                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2302                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2303                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2304                   {
2305                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2306                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2307                         ueCb->f1apMsgDb.duToCuContainer.size);
2308                   }
2309                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2310                   {
2311                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2312                      ret = RFAILED;
2313                   }
2314                }
2315                else
2316                {
2317                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2318                   ret = RFAILED;
2319                }
2320                break;
2321             }
2322
2323          default:
2324             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2325             break;
2326       }
2327       if(ret == RFAILED)
2328          break;
2329    }
2330
2331    if(ret == ROK)
2332    {
2333       ueCb->f1apMsgDb.dlRrcMsgCount++;
2334       rrcMsgType = setDlRRCMsgType(ueCb);
2335       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2336    }
2337    return ret;
2338 }
2339
2340 /*******************************************************************
2341  *
2342  * @brief Builds Nrcgi
2343  *
2344  * @details
2345  *
2346  *    Function : BuildNrcgi
2347  *
2348  *    Functionality: Building the PLMN ID and NR Cell id
2349  *
2350  * @params[in] NRCGI_t *nrcgi
2351  * @return ROK     - success
2352  *         RFAILED - failure
2353  *
2354  * ****************************************************************/
2355 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2356 {
2357    uint8_t ret;
2358    uint8_t unused_bits = 4;
2359    uint8_t byteSize = 5;
2360
2361    /* Allocate Buffer Memory */
2362    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2363    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2364    if(nrcgi->pLMN_Identity.buf == NULLP)
2365    {
2366       return RFAILED;
2367    }
2368    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2369
2370    if(ret != ROK)
2371    {
2372       return RFAILED;
2373    }
2374    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2375    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2376    if(nrcgi->nRCellIdentity.buf == NULLP)
2377    {
2378       return RFAILED;
2379    }
2380    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2381
2382    return ROK;
2383 }
2384 /*******************************************************************
2385  *
2386  * @brief Builds Special cell list for UE Setup Request
2387  *
2388  * @details
2389  *
2390  *    Function : BuildSplCellList
2391  *
2392  *    Functionality: Constructs the Special Cell list for UESetReq
2393  *
2394  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2395  *
2396  * @return ROK     - success
2397  *         RFAILED - failure
2398  *
2399  * ****************************************************************/
2400 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2401 {
2402    uint8_t  cellCnt;
2403    uint8_t  idx;
2404    uint8_t  ret;
2405    cellCnt = 1;
2406    spCellLst->list.count = cellCnt;
2407    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2408    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2409    if(spCellLst->list.array == NULLP)
2410    {
2411       return RFAILED;
2412    }
2413    for(idx=0; idx<cellCnt; idx++)
2414    {
2415       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2416       if(spCellLst->list.array[idx] == NULLP)
2417       {
2418          return RFAILED;
2419       }
2420    }
2421    idx = 0;
2422    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2423    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2424    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2425
2426    /* Special Cell ID -NRCGI */
2427    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2428    if(ret != ROK)
2429    {
2430       return RFAILED;
2431    }
2432    /*Special Cell Index*/
2433    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2434    return ROK;
2435 }/* End of BuildSplCellList*/
2436
2437 /*******************************************************************
2438  *
2439  * @brief Builds SRBS to be setup
2440  *
2441  * @details
2442  *
2443  *    Function : BuildSRBSetup
2444  *
2445  *    Functionality: Constructs the SRB's for UESetReq
2446  *
2447  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2448  *
2449  * @return ROK     - success
2450  *         RFAILED - failure
2451  *
2452  * ****************************************************************/
2453 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2454 {
2455    uint8_t idx;
2456    uint8_t srbCnt;
2457
2458    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2459       srbCnt = ueCb->numSrb;
2460    else
2461       srbCnt = 1;
2462    srbSet->list.count = srbCnt;
2463    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2464    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2465    if(srbSet->list.array == NULLP)
2466    {
2467       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2468       return RFAILED;
2469    }
2470
2471    for(idx=0; idx<srbCnt; idx++)
2472    {
2473       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2474       if(srbSet->list.array[idx] == NULLP)
2475       {
2476          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2477          return RFAILED;
2478       }
2479    }
2480
2481    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2482    {
2483       idx = 0;
2484       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2485       srbSet->list.array[idx]->criticality = Criticality_ignore;
2486       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2487       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2488       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2489       ueCb->numSrb++;
2490    }
2491    else
2492    {
2493       for(idx=0; idx<srbCnt; idx++)
2494       {
2495          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2496          srbSet->list.array[idx]->criticality = Criticality_ignore;
2497          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2498          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2499       }
2500    }
2501    return ROK;
2502 }/* End of BuildSRBSetup*/
2503
2504 /*******************************************************************
2505  *
2506  * @brief Builds QOS Info for DRB Setum Item
2507  *
2508  * @details
2509  *
2510  *    Function : BuildQOSInfo
2511  *
2512  *    Functionality: Constructs the QOS Info for DRB Setup Item
2513  *
2514  * @params[in] QoSInformation_t *qosinfo
2515  *             int16_t pduSessionID
2516  *
2517  * @return ROK     - success
2518  *         RFAILED - failure
2519  *
2520  * ****************************************************************/
2521 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2522 {
2523    uint8_t elementCnt = 0, qosCntIdx = 0;
2524    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2525
2526    /* NonDynamic5QIDescriptor */
2527    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2528    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2529    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2530    {
2531       return RFAILED;
2532    }
2533
2534    if(hoInProgress)
2535       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2536    else
2537    {
2538       /*FiveQI*/
2539       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2540          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2541       else
2542          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2543
2544       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2545    }
2546
2547    if(!hoInProgress)
2548    {
2549       /*AveragingWindow*/
2550       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2551       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2552       {
2553          return RFAILED;
2554       }
2555       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2556       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2557
2558       /*MaxDataBurstVolume*/
2559       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2560       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2561       {
2562          return RFAILED;
2563       }
2564       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2565       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2566    }
2567
2568    /*nRGRAN Allocation Retention Priority*/
2569    if(hoInProgress)
2570    {
2571       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2572       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2573       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2574    }
2575    else
2576    {
2577       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2578       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2579       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2580
2581       qosInfo->priorityLevel = PriorityLevel_lowest;
2582       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2583       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2584    }
2585
2586    /* PDU session ID */
2587    if(!hoInProgress)
2588    {
2589       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2590       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2591       {
2592          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2593          return ROK;
2594       }
2595
2596       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2597       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2598
2599       if(qosIeExt)
2600       {
2601          elementCnt = NUM_QOS_EXT;
2602          qosIeExt->list.count = elementCnt;
2603          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2604
2605          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2606          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2607
2608          if(qosIeExt->list.array == NULLP)
2609          {
2610             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2611             return  RFAILED;
2612          }
2613
2614          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2615          {
2616             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2617             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2618             {
2619                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2620                return  RFAILED;
2621             }
2622             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2623             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2624             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2625             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2626             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2627                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2628             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2629             qosInfo->pduSessionId = pduSessionID;
2630          }
2631       }
2632       else
2633       {
2634          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2635          return RFAILED;
2636       }
2637    }
2638    return ROK;
2639 }/*End of BuildQOSInfo*/
2640
2641 /*******************************************************************
2642  *
2643  * @brief Builds SNSSAI
2644  *
2645  * @details
2646  *
2647  *    Function : BuildSNSSAI
2648  *
2649  *    Functionality: Constructs the SNSSAI For DRB list
2650  *
2651  * @params[in] SNSSAI_t *snssai
2652  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2653  *
2654  * @return ROK     - success
2655  *         RFAILED - failure
2656  *
2657  * ****************************************************************/
2658 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2659 {
2660    /*SNSSAI*/
2661    /*ssT*/
2662    snssai->sST.size = sizeof(uint8_t);
2663    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2664    if(snssai->sST.buf == NULLP)
2665    {
2666       return RFAILED;
2667    }
2668    if(!hoInProgress)
2669       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2670    else
2671       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2672
2673    /*sD*/
2674    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2675    if(snssai->sD == NULLP)
2676    {
2677       return RFAILED;
2678    }
2679    snssai->sD->size = 3 * sizeof(uint8_t);
2680    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2681    if(snssai->sD->buf == NULLP)
2682    {
2683       return RFAILED;
2684    }
2685    if(!hoInProgress)
2686       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2687    else
2688       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2689
2690    if(!hoInProgress)
2691       drbInfo->snssai = snssaiToCopy;
2692    return ROK;
2693 }/*End of BuildSNSSAI*/
2694
2695 /*******************************************************************
2696  *
2697  * @brief Builds the flow map.
2698  *
2699  * @details
2700  *
2701  *    Function : BuildFlowsMap
2702  *
2703  *    Functionality: Constructs the flowmap For DRB list
2704  *
2705  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2706  *
2707  * @return ROK     - success
2708  *         RFAILED - failure
2709  *
2710  * ****************************************************************/
2711 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2712 {
2713    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2714    FlowsMapped *qosFlow;
2715
2716    if(!hoInProgress)
2717       flowCnt = 1;
2718    else
2719       flowCnt = drbInfo->numFlowMap;
2720    flowMap->list.count = flowCnt;
2721    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2722    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2723    if(flowMap->list.array == NULLP)
2724    {
2725       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2726       return RFAILED;
2727    }
2728    for(idx=0; idx<flowCnt; idx++)
2729    {
2730       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2731       if(flowMap->list.array[idx] == NULLP)
2732       {
2733          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2734          return RFAILED;
2735       }
2736
2737       if(!hoInProgress)
2738       {
2739          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2740          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2741          {
2742             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2743             {
2744                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2745                {
2746                   qosFlow = &drbInfo->flowMapList[flowIdx];
2747                   break;
2748                }
2749             }
2750          }
2751          else
2752          {
2753             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2754             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2755          }
2756       }
2757       else
2758       {
2759          qosFlow = &drbInfo->flowMapList[idx];
2760          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2761       }
2762
2763       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2764             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2765       if(ret != ROK)
2766       {
2767          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2768          return RFAILED;
2769       }
2770
2771       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2772          drbInfo->numFlowMap++;
2773    }
2774    return ROK;
2775 }/*End of BuildFlowsMap*/
2776
2777 /*******************************************************************
2778  *
2779  * @brief Builds the Uplink Tunnel Info
2780  *
2781  * @details
2782  *
2783  *    Function : BuildULTnlInfo
2784  *
2785  *    Functionality: Constructs the UL TnlInfo For DRB list
2786  *
2787  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2788  *
2789  * @return ROK     - success
2790  *         RFAILED - failure
2791  *
2792  * ****************************************************************/
2793 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2794 {
2795    uint8_t idx;
2796    uint8_t ulCnt;
2797
2798    ulCnt = 1;
2799    ulInfo->list.count = ulCnt;
2800    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2801    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2802    if(ulInfo->list.array == NULLP)
2803    {
2804       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2805       return RFAILED;
2806    }
2807    for(idx=0; idx<ulCnt; idx++)
2808    {
2809       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2810       if(ulInfo->list.array[idx] == NULLP)
2811       {
2812          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2813               return RFAILED;
2814       }
2815    }
2816    idx = 0;
2817    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2818    /*GTP TUNNEL*/
2819    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2820    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2821    {
2822       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2823       return RFAILED;
2824    }
2825    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2826    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2827       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2828    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2829    {
2830       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2831       return RFAILED;
2832    }
2833
2834    if(!hoInProgress)
2835    {
2836       /* NOTE: Below IP address must be changed if running on different IP configuration */
2837       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2838       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2839       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2840       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2841       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2842
2843       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2844       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2845       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2846       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2847    }
2848    else
2849    {
2850       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2851       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2852       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2853       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2854       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2855    }
2856
2857    /*GTP TEID*/
2858    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2859    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2860       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2861    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2862    {
2863       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2864       return RFAILED;
2865    }
2866
2867    if(!hoInProgress)
2868    {
2869       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2870       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2871       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2872       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2873
2874       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2875       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2876       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2877       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2878    }
2879    else
2880    {
2881       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2882       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2883       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2884       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2885    }
2886    return ROK;
2887 }/*End of BuildULTnlInfo*/
2888
2889 /*******************************************************************
2890  *
2891  * @brief Builds DRBS to be setup
2892  *
2893  * @details
2894  *
2895  *    Function : BuildDRBSetup
2896  *
2897  *    Functionality: Constructs the DRB's for UESetReq
2898  *
2899  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2900  *
2901  * @return ROK     - success
2902  *         RFAILED - failure
2903  *
2904  * ****************************************************************/
2905 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2906 {
2907    uint16_t snssaiIdx=0;
2908    uint8_t idx = 0, extIeIdx = 0;
2909    uint8_t elementCnt = 0, drbCnt = 0;
2910    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2911    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2912    DRBs_ToBeSetup_Item_t *drbSetItem;
2913    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2914    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2915
2916    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2917       drbCnt = ueCb->numDrb;
2918    else
2919       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2920    drbSet->list.count = drbCnt;
2921
2922    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2923    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2924    if(drbSet->list.array == NULLP)
2925    {
2926       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2927       return RFAILED;
2928    }
2929
2930    for(idx=0; idx<drbCnt; idx++)
2931    {
2932       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2933       if(drbSet->list.array[idx] == NULLP)
2934       {
2935          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2936          return RFAILED;
2937       }
2938
2939       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2940       drbSet->list.array[idx]->criticality = Criticality_ignore;
2941       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2942       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2943       /*dRBID*/
2944       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2945       {
2946          drbSetItem->dRBID = idx + 1;
2947          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2948       }
2949       else
2950          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2951
2952       /*qoSInformation*/
2953       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2954       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2955       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2956       {
2957          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2958          return RFAILED;
2959       }
2960       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2961       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2962       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2963       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2964          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2965                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2966       else
2967          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2968                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2969       if(BuildQOSInforet != ROK)
2970       {
2971          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2972          return RFAILED;
2973       }
2974
2975       /*SNSSAI*/
2976       snssaiIdx = (idx% cuCb.numSnssaiSupported);
2977       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2978          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2979                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
2980       else
2981          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2982                choice_extension->value.choice.DRB_Information.sNSSAI, NULLP, TRUE);
2983       if(BuildSNSSAIret != ROK)
2984       {
2985          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2986          return RFAILED;
2987       }
2988
2989       /*Flows mapped to DRB List*/
2990       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2991          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2992                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2993       else
2994          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2995                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2996       if(BuildFlowsMapret != ROK)
2997       {
2998          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2999          return RFAILED;
3000       }
3001
3002       /*ULUPTNLInformation To Be Setup List*/
3003       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3004          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3005                FALSE);
3006       else
3007          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3008                TRUE);
3009       if(BuildULTnlInforet != ROK)
3010       {
3011          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
3012          return RFAILED;
3013       }
3014
3015       /*RLCMode*/
3016       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3017       {
3018          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
3019          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
3020       }
3021       else
3022          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
3023
3024       /* DL PDCP SN Length */
3025       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
3026       {
3027          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
3028          if(!drbToBeSetupExt)
3029          {
3030             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
3031             return RFAILED;
3032          }
3033
3034          elementCnt = 1;
3035          drbToBeSetupExt->list.count = elementCnt;
3036          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
3037
3038          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
3039          if(!drbToBeSetupExt->list.array)
3040          {
3041              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
3042              return RFAILED;
3043          }
3044
3045          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
3046          {
3047             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
3048             if(!drbToBeSetupExt->list.array[extIeIdx])
3049             {
3050                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
3051                return RFAILED;
3052             }
3053          }
3054
3055          extIeIdx = 0;
3056          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
3057
3058          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
3059          drbToBeSetupExtIe->criticality = Criticality_ignore;
3060          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
3061          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
3062          drbSetItem->iE_Extensions = drbToBeSetupExt;
3063       }
3064
3065       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3066          ueCb->numDrb++;
3067    }
3068    return ROK;
3069 }/* End of BuildDRBSetup*/
3070
3071 /*******************************************************************
3072  *
3073  * @brief Deallocating memory of function BuildAndSendUESetReq
3074  *
3075  * @details
3076  *
3077  *    Function : FreeNrcgi
3078  *
3079  *    Functionality: Deallocating memory for function BuildNrcgi
3080  *
3081  * @params[in] NRCGI_t *nrcgi
3082  *
3083  * @return void
3084  *
3085  *******************************************************************/
3086 void FreeNrcgi(NRCGI_t *nrcgi)
3087 {
3088    if(nrcgi->pLMN_Identity.buf != NULLP)
3089    {
3090       if(nrcgi->nRCellIdentity.buf != NULLP)
3091       {
3092          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
3093       }
3094       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
3095    }
3096 }
3097 /*******************************************************************
3098  *
3099  * @brief  Deallocating memory of function BuildAndSendUESetReq
3100  *
3101  * @details
3102  *
3103  *    Function : FreeSplCellList
3104  *
3105  *    Functionality: Deallocating memory for function BuildSplCellList
3106  *
3107  * @params[in] SCell_ToBeSetup_List_t *spCellLst
3108  *
3109  * @return void
3110  *
3111  *
3112  * *****************************************************************/
3113 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
3114 {
3115    uint8_t  cellidx;
3116    if(spCellLst->list.array != NULLP)
3117    {
3118       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
3119       {
3120          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
3121          {
3122             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
3123          }
3124          if(spCellLst->list.array[cellidx]!=NULLP)
3125          {
3126             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
3127          }
3128       }
3129       CU_FREE(spCellLst->list.array,spCellLst->list.size);
3130    }
3131 }
3132 /*******************************************************************
3133  *
3134  * @brief Deallocating memory of function BuildAndSendUESetReq
3135  *
3136  * @details
3137  *
3138  *    Function : FreeSRBSetup
3139  *
3140  *    Functionality: Deallocating memory for function BuildSRBSetup
3141  *
3142  * @params[in] SRBs_ToBeSetup_List_t *srbSet
3143  *
3144  * @return void
3145  *
3146  *
3147  * ******************************************************************/
3148 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
3149 {
3150    uint8_t srbidx;
3151    if(srbSet->list.array != NULLP)
3152    {
3153       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
3154       {
3155          if(srbSet->list.array[srbidx]!=NULLP)
3156          {
3157             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
3158          }
3159       }
3160       CU_FREE(srbSet->list.array,srbSet->list.size);
3161    }
3162 }
3163 /*******************************************************************
3164  *
3165  * @brief Deallocating memory of function BuildAndSendUESetReq
3166  *
3167  * @details
3168  *
3169  *    Function : FreeQOSInfo
3170  *
3171  *    Functionality:  Deallocating memory for function BuildQOSInfo
3172  *
3173  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
3174  *
3175  * @return void
3176  *
3177  * ****************************************************************/
3178 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
3179 {
3180    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3181    uint8_t qosCntIdx = 0;
3182
3183    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
3184    {
3185       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3186       {
3187          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3188          {
3189             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3190                   sizeof(MaxDataBurstVolume_t));
3191          }
3192          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3193                sizeof(AveragingWindow_t));
3194       }
3195       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3196             sizeof(NonDynamic5QIDescriptor_t));
3197    }
3198    if(drbQos->iE_Extensions)
3199    {
3200       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
3201       if(qosIeExt->list.array != NULLP)
3202       {
3203          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
3204          {
3205             if(qosIeExt->list.array[qosCntIdx])
3206             {
3207                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3208             }
3209          }
3210          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3211       }
3212
3213       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3214    }
3215 }
3216 /*******************************************************************
3217  *
3218  * @brief Deallocating memory of function BuildAndSendUESetReq
3219  *
3220  * @details
3221  *
3222  *    Function : FreeULTnlInfo
3223  *
3224  *    Functionality:  Deallocating memory for function BuildULTnlInfo
3225  *
3226  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
3227  *
3228  * @return void
3229  *
3230
3231  * ****************************************************************/
3232 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
3233 {
3234    uint8_t ulidx=0;
3235    if(ulInfo->list.array != NULLP)
3236    {
3237       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
3238       {
3239          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3240          {
3241             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3242             {
3243                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3244                      transportLayerAddress.buf != NULLP)
3245                {
3246                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3247                         !=NULLP)
3248                   {
3249                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3250                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3251                            gTPTunnel->gTP_TEID.size);
3252                   }
3253                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3254                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3255                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3256                }
3257                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3258                      sizeof(GTPTunnel_t));
3259             }
3260          }
3261          if(ulInfo->list.array[ulidx]!=NULLP)
3262          {
3263             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3264          }
3265       }
3266       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3267    }
3268 }
3269 /*******************************************************************
3270  *
3271  * @brief Deallocating memory for BuildAndSendUESetReq
3272  *
3273  * @details
3274  *
3275  *    Function : FreeDRBSetup
3276  *
3277  *    Functionality:  Deallocating memory for BuildDRBSetup
3278  *
3279  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3280  *
3281  * @return void
3282  *
3283  * ****************************************************************/
3284 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3285 {
3286    DRBs_ToBeSetup_Item_t *drbSetItem;
3287    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3288
3289    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3290
3291    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3292    if(drbSet->list.array != NULLP)
3293    {
3294       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3295       {
3296               if(drbSet->list.array[drbidx] != NULLP)
3297               {
3298                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3299                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3300                  {
3301                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3302                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3303                {
3304                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3305                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3306                             {
3307                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3308                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3309                                {
3310                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3311                                        {
3312                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3313                                           {
3314                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3315                                              {
3316                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3317                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3318                                                      {
3319                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3320                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3321                                                          {
3322                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3323                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3324                                                              {
3325                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3326                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3327                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3328                                                                      {
3329                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3330                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3331                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3332                                                                          {
3333                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3334                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3335                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3336                                                                                   {
3337                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3338                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3339
3340                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3341                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3342                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3343                                                                                                    sizeof(MaxDataBurstVolume_t));
3344                                                                                   }
3345                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3346                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3347                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3348                                                                          }
3349                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3350                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3351                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3352                                                                      }
3353                                                             }
3354                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3355                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3356                                                             {
3357                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3358                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3359                                                             }
3360                                                         }
3361                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3362                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3363                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3364                                                      }
3365                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3366                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3367                                             }
3368                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3369                                                               sizeof(OCTET_STRING_t));
3370                                        }
3371                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3372                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3373                                     }
3374                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3375                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3376                             }
3377                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3378                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3379                          }
3380                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3381                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3382              }
3383              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3384                         iE_Extensions != NULLP)
3385              {
3386                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3387                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3388                  if(qosIeExt->list.array != NULLP)
3389                  {
3390                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3391                    {
3392                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3393                       {
3394                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3395                       }
3396                     }
3397                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3398                   }
3399                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3400                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3401               }
3402
3403                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3404                 }
3405                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3406               }
3407       }
3408       CU_FREE(drbSet->list.array,drbSet->list.size);
3409    }
3410 }
3411
3412
3413 /*******************************************************************
3414  *
3415  * @brief Free the UE Setup Request
3416  *
3417  * @details
3418  *
3419  *    Function : FreeUeContextSetupReq
3420  *
3421  *    Functionality: Deallocate the memory of BuildUESetReq
3422  *
3423  * @params[in]  F1AP_PDU_t  *f1apMsg
3424  *
3425  * @return void
3426  *
3427  *
3428  * ****************************************************************/
3429 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3430 {
3431    uint8_t idx, ieId;
3432    UEContextSetupRequest_t  *ueSetReq = NULLP;
3433
3434    if(f1apMsg != NULLP)
3435    {
3436       if(f1apMsg->choice.initiatingMessage != NULLP)
3437       {
3438          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3439          if(ueSetReq->protocolIEs.list.array != NULLP)
3440          {
3441             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3442             {
3443                if(ueSetReq->protocolIEs.list.array[idx])
3444                {
3445                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3446                   {
3447                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3448                         break;
3449                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3450                         break;
3451                      case ProtocolIE_ID_id_SpCell_ID:
3452                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3453                         break;
3454                      case ProtocolIE_ID_id_ServCellIndex:
3455                         break;
3456                      case ProtocolIE_ID_id_SpCellULConfigured:
3457                         break;
3458                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3459                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3460                         break;
3461                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3462                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3463                         break;
3464                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3465                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3466                         break;
3467                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3468                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3469                         break;
3470                      case ProtocolIE_ID_id_RRCContainer:
3471                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3472                         {
3473                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3474                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3475                         }
3476                         break;
3477                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3478                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3479                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3480                         break;
3481                      default:
3482                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3483                         break;
3484                   }
3485                }
3486                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3487             }
3488             for(ieId=0; ieId<idx; ieId++)
3489             {
3490                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3491                {
3492                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3493                }
3494             }
3495             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3496          }
3497          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3498       }
3499       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3500    }
3501 }
3502
3503 /**Filling cell group info **/
3504 /*******************************************************************
3505  *
3506  * @brief Build Control resource set to add/modify list
3507  *
3508  * @details
3509  *
3510  *    Function : BuildControlRSetToAddModList
3511  *
3512  *    Functionality: Build Control resource set to add/modify list
3513  *
3514  * @params[in]
3515  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3516  *
3517  * @return ROK     - success
3518  *         RFAILED - failure
3519  *
3520  * ****************************************************************/
3521    uint8_t BuildControlRSetToAddModList
3522 (
3523  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3524  )
3525 {
3526    uint8_t idx;
3527    uint8_t elementCnt;
3528    uint8_t numBytes, bitsUnused;
3529    struct ControlResourceSet *controlRSet;
3530    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3531    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3532
3533    elementCnt = 1;
3534    controlRSetList->list.count = elementCnt;
3535    controlRSetList->list.size = \
3536                                 elementCnt * sizeof(struct ControlResourceSet *);
3537
3538    controlRSetList->list.array = NULLP;
3539    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3540    if(!controlRSetList->list.array)
3541    {
3542       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3543       return RFAILED;
3544    }
3545
3546    for(idx = 0; idx < elementCnt; idx++)
3547    {
3548       controlRSetList->list.array[idx] = NULLP;
3549       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3550       if(!controlRSetList->list.array[idx])
3551       {
3552          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3553          return RFAILED;
3554       }
3555    }
3556
3557    idx=0;
3558    controlRSet = controlRSetList->list.array[idx];
3559    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3560
3561    /* Values harcoded according to our design:
3562     * size 6 bytes
3563     * 3 LSBs unsued
3564     * Bit string stored ff0000000000
3565     */
3566    numBytes = 6;
3567    bitsUnused = 3;
3568    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3569    controlRSet->frequencyDomainResources.buf = NULLP;
3570    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3571          controlRSet->frequencyDomainResources.size);
3572    if(!controlRSet->frequencyDomainResources.buf)
3573    {
3574       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3575       return RFAILED;
3576    }
3577
3578    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3579    coreset0EndPrb = CORESET0_END_PRB;
3580    coreset1StartPrb = coreset0EndPrb + 6;
3581    coreset1NumPrb = CORESET1_NUM_PRB;
3582    /* calculate the PRBs */
3583    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3584    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3585    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3586
3587    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3588    controlRSet->cce_REG_MappingType.present = \
3589                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3590
3591    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3592    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3593    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3594    controlRSet->tci_PresentInDCI = NULLP;
3595 #if 0
3596    uint8_t tciStateIdx;
3597
3598    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3599          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3600    if(!controlRset->tci_StatesPDCCH_ToAddList)
3601    {
3602       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3603       return RFAILED;
3604    }
3605
3606    elementCnt = 1;
3607    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3608    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3609    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3610          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3611       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3612       {
3613          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3614          return RFAILED;
3615       }
3616
3617    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3618    {
3619       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3620       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3621       {
3622          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3623          return RFAILED;
3624       }
3625    }
3626
3627    tciStateIdx = 0;
3628    /* TODO */
3629    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3630
3631    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3632    if(!controlRset->tci_PresentInDCI)
3633    {
3634       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3635       return RFAILED;
3636    }
3637    /* TODO */
3638    *(controlRset->tci_PresentInDCI);
3639 #endif
3640
3641    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3642    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3643    if(!controlRSet->pdcch_DMRS_ScramblingID)
3644    {
3645       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3646       return RFAILED;
3647    }
3648    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3649
3650    return ROK;
3651 } /* End BuildControlRSetToAddModList */
3652
3653 /*******************************************************************
3654  *
3655  * @brief Build search space to add/modify list
3656  *
3657  * @details
3658  *
3659  *    Function : BuildSearchSpcToAddModList
3660  *
3661  *    Functionality: Build search space to add/modify list
3662  *
3663  * @params[in]
3664  * @return ROK     - success
3665  *         RFAILED - failure
3666  *
3667  * ****************************************************************/
3668    uint8_t BuildSearchSpcToAddModList
3669 (
3670  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3671  )
3672 {
3673    uint8_t idx;
3674    uint8_t numBytes;
3675    uint8_t byteIdx;
3676    uint8_t bitsUnused;
3677    uint8_t elementCnt;
3678    struct SearchSpace *searchSpc;
3679
3680    elementCnt = 1;
3681    searchSpcList->list.count = elementCnt;
3682    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3683
3684    searchSpcList->list.array = NULLP;
3685    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3686    if(!searchSpcList->list.array)
3687    {
3688       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3689       return RFAILED;
3690    }
3691
3692    for(idx = 0; idx < elementCnt; idx++)
3693    {
3694       searchSpcList->list.array[idx] = NULLP;
3695       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3696       if(!searchSpcList->list.array[idx])
3697       {
3698          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3699          return RFAILED;
3700       }
3701    }
3702
3703    idx = 0;
3704    searchSpc = searchSpcList->list.array[idx];
3705
3706    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3707
3708    searchSpc->controlResourceSetId = NULLP;
3709    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3710    if(!searchSpc->controlResourceSetId)
3711    {
3712       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3713       return RFAILED;
3714    }
3715    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3716
3717    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3718    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3719          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3720    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3721    {
3722       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3723       return RFAILED;
3724    }
3725    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3726                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3727
3728    searchSpc->duration = NULLP;
3729    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3730    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3731    if(!searchSpc->monitoringSymbolsWithinSlot)
3732    {
3733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3734       return RFAILED;
3735    }
3736
3737    /* Values taken from reference logs :
3738     * size 2 bytes
3739     * 2 LSBs unsued
3740     * Bit string stores 8000
3741     */
3742    numBytes = 2;
3743    bitsUnused = 2;
3744
3745    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3746    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3747    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3748          searchSpc->monitoringSymbolsWithinSlot->size);
3749    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3750    {
3751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3752       return RFAILED;
3753    }
3754
3755    byteIdx = 0;
3756    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3757                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3758    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3759    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3760
3761    searchSpc->nrofCandidates = NULLP;
3762    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3763    if(!searchSpc->nrofCandidates)
3764    {
3765       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3766       return RFAILED;
3767    }
3768
3769    searchSpc->nrofCandidates->aggregationLevel1 = \
3770                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3771    searchSpc->nrofCandidates->aggregationLevel2 = \
3772                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3773    searchSpc->nrofCandidates->aggregationLevel4 = \
3774                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3775    searchSpc->nrofCandidates->aggregationLevel8 = \
3776                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3777    searchSpc->nrofCandidates->aggregationLevel16 = \
3778                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3779
3780    searchSpc->searchSpaceType = NULLP;
3781    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3782    if(!searchSpc->searchSpaceType)
3783    {
3784       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3785       return RFAILED;
3786    }
3787
3788    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3789
3790    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3791    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3792          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3793    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3794    {
3795       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3796       return RFAILED;
3797    }
3798    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3799                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3800
3801    return ROK;
3802 }/* End BuildSearchSpcToAddModList */
3803
3804 /*******************************************************************
3805  *
3806  * @brief Builds BWP DL dedicated PDCCH config
3807  *
3808  * @details
3809  *
3810  *    Function : BuildBWPDlDedPdcchCfg
3811  *
3812  *    Functionality: Builds BWP DL dedicated PDCCH config
3813  *
3814  * @params[in] struct PDCCH_Config *pdcchCfg
3815  *
3816  * @return ROK     - success
3817  *         RFAILED - failure
3818  *
3819  * ****************************************************************/
3820 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3821 {
3822    pdcchCfg->controlResourceSetToAddModList = NULLP;
3823    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3824          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3825    if(!pdcchCfg->controlResourceSetToAddModList)
3826    {
3827       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3828       return RFAILED;
3829    }
3830
3831    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3832    {
3833       return RFAILED;
3834    }
3835
3836    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3837
3838    pdcchCfg->searchSpacesToAddModList = NULLP;
3839    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3840          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3841    if(!pdcchCfg->searchSpacesToAddModList)
3842    {
3843       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3844       return RFAILED;
3845    }
3846
3847    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3848    {
3849       return RFAILED;
3850    }
3851
3852    pdcchCfg->searchSpacesToReleaseList = NULLP;
3853    pdcchCfg->downlinkPreemption = NULLP;
3854    pdcchCfg->tpc_PUSCH = NULLP;
3855    pdcchCfg->tpc_PUCCH = NULLP;
3856    pdcchCfg->tpc_SRS = NULLP;
3857
3858    return ROK;
3859 }
3860
3861 /*******************************************************************
3862  *
3863  * @brief Builds DMRS DL PDSCH Mapping type A
3864  *
3865  * @details
3866  *
3867  *    Function : BuildDMRSDLPdschMapTypeA
3868  *
3869  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3870  *
3871  * @params[in]
3872  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3873  * @return ROK     - success
3874  *         RFAILED - failure
3875  *
3876  * ****************************************************************/
3877    uint8_t BuildDMRSDLPdschMapTypeA
3878 (
3879  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3880  )
3881 {
3882    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3883    dmrsDlCfg->choice.setup = NULLP;
3884    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3885    if(!dmrsDlCfg->choice.setup)
3886    {
3887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3888       return RFAILED;
3889    }
3890
3891    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3892    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3893    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3894    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3895    {
3896       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3897       return RFAILED;
3898    }
3899    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3900
3901    dmrsDlCfg->choice.setup->maxLength = NULLP;
3902    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3903    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3904    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3905
3906    return ROK;
3907 }
3908
3909 /*******************************************************************
3910  *
3911  * @brief Builds TCI states to add/modify list
3912  *
3913  * @details
3914  *
3915  *    Function : BuildTCIStatesToAddModList
3916  *
3917  *    Functionality:Builds TCI states to add/modify list
3918  *
3919  * @params[in]
3920  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3921  *
3922  * @return ROK     - success
3923  *         RFAILED - failure
3924  *
3925  * ****************************************************************/
3926 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3927 {
3928    return ROK;
3929 }
3930
3931 /*******************************************************************
3932  *
3933  * @brief Builds PDSCH time domain allocation list
3934  *
3935  * @details
3936  *
3937  *    Function : BuildPdschTimeDomAllocList
3938  *
3939  *    Functionality: Builds PDSCH time domain allocation list
3940  *
3941  * @params[in]
3942  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3943  *
3944  * @return ROK     - success
3945  *         RFAILED - failure
3946  *
3947  * ****************************************************************/
3948    uint8_t BuildPdschTimeDomAllocList
3949 (
3950  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3951  )
3952 {
3953    uint8_t idx;
3954    uint8_t elementCnt;
3955    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3956
3957    timeDomAllocList->present = \
3958                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3959
3960    timeDomAllocList->choice.setup = NULLP;
3961    CU_ALLOC(timeDomAllocList->choice.setup, \
3962          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3963    if(!timeDomAllocList->choice.setup)
3964    {
3965       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3966       return RFAILED;
3967    }
3968
3969    elementCnt = 2;
3970    timeDomAllocList->choice.setup->list.count = elementCnt;
3971    timeDomAllocList->choice.setup->list.size = \
3972                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3973
3974    timeDomAllocList->choice.setup->list.array = NULLP;
3975    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3976          timeDomAllocList->choice.setup->list.size);
3977    if(!timeDomAllocList->choice.setup->list.array)
3978    {
3979       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3980       return RFAILED;
3981    }
3982
3983    for(idx = 0; idx < elementCnt; idx++)
3984    {
3985       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3986       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3987             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3988       if(!timeDomAllocList->choice.setup->list.array[idx])
3989       {
3990          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3991          return RFAILED;
3992       }
3993    }
3994
3995    idx = 0;
3996    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3997    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3998    if(!timeDomAlloc->k0)
3999    {
4000        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4001        return RFAILED;
4002    }
4003    *(timeDomAlloc->k0) = 0;
4004    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4005    timeDomAlloc->startSymbolAndLength = 66;
4006
4007    idx++;
4008    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4009    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4010    if(!timeDomAlloc->k0)
4011    {
4012       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4013       return RFAILED;
4014    }
4015    *(timeDomAlloc->k0) = 1;
4016    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4017    timeDomAlloc->startSymbolAndLength = 66;
4018
4019    return ROK;
4020 }
4021
4022 /*******************************************************************
4023  *
4024  * @brief Builds PDSCH PRB Bundling type
4025  *
4026  * @details
4027  *
4028  *    Function : BuildPdschPrbBundlingType
4029  *
4030  *    Functionality: Builds PDSCH PRB Bundling type
4031  *
4032  * @params[in]
4033  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4034  *
4035  * @return ROK     - success
4036  *         RFAILED - failure
4037  *
4038  * ****************************************************************/
4039    uint8_t BuildPdschPrbBundlingType
4040 (
4041  struct PDSCH_Config__prb_BundlingType *prbBndlType
4042  )
4043 {
4044    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4045
4046    prbBndlType->choice.staticBundling = NULLP;
4047    CU_ALLOC(prbBndlType->choice.staticBundling, \
4048          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4049    if(!prbBndlType->choice.staticBundling)
4050    {
4051       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4052       return RFAILED;
4053    }
4054    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4055
4056    return ROK;
4057 }
4058
4059 /*******************************************************************
4060  *
4061  * @brief Builds BWP DL dedicated PDSCH config
4062  *
4063  * @details
4064  *
4065  *    Function : BuildBWPDlDedPdschCfg
4066  *
4067  *    Functionality: Builds BWP DL dedicated PDSCH config
4068  *
4069  * @params[in] struct PDSCH_Config *pdschCfg
4070  *
4071  * @return ROK     - success
4072  *         RFAILED - failure
4073  *
4074  * ****************************************************************/
4075 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4076 {
4077    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4078
4079    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4080    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4081          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4082    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4083    {
4084       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4085       return RFAILED;
4086    }
4087
4088    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4089    {
4090       return RFAILED;
4091    }
4092
4093    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4094    pdschCfg->tci_StatesToAddModList = NULLP;
4095    pdschCfg->tci_StatesToReleaseList = NULLP;
4096    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4097 #if 0
4098    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4099    if(!pdschCfg->tci_StatesToAddModList)
4100    {
4101       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4102       return RFAILED;
4103    }
4104    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4105    {
4106       return RFAILED;
4107    }
4108 #endif
4109
4110    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4111
4112    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4113    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4114          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4115    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4116    {
4117       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4118       return RFAILED;
4119    }
4120    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4121    {
4122       return RFAILED;
4123    }
4124    pdschCfg->pdsch_AggregationFactor = NULLP;
4125    pdschCfg->rateMatchPatternToAddModList = NULLP;
4126    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4127    pdschCfg->rateMatchPatternGroup1 = NULLP;
4128    pdschCfg->rateMatchPatternGroup2 = NULLP;
4129    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4130    pdschCfg->mcs_Table = NULLP;
4131
4132    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4133    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4134    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4135    {
4136       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4137       return RFAILED;
4138    }
4139    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4140
4141    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4142    {
4143       return RFAILED;
4144    }
4145
4146    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4147    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4148    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4149    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4150    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4151    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4152    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4153
4154    return ROK;
4155 }
4156
4157 /*******************************************************************
4158  *
4159  * @brief Builds intitial DL BWP
4160  * @details
4161  *
4162  *    Function : BuildInitialDlBWP
4163  *
4164  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4165  *
4166  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4167  *
4168  * @return ROK     - success
4169  *         RFAILED - failure
4170  *
4171  * ****************************************************************/
4172 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4173 {
4174    dlBwp->pdcch_Config = NULLP;
4175    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4176    if(!dlBwp->pdcch_Config)
4177    {
4178       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4179       return RFAILED;
4180    }
4181    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4182
4183    dlBwp->pdcch_Config->choice.setup = NULLP;
4184    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4185    if(!dlBwp->pdcch_Config->choice.setup)
4186    {
4187       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4188       return RFAILED;
4189    }
4190    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4191    {
4192       return RFAILED;
4193    }
4194
4195    dlBwp->pdsch_Config = NULLP;
4196    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4197    if(!dlBwp->pdsch_Config)
4198    {
4199       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4200       return RFAILED;
4201    }
4202    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4203
4204    dlBwp->pdsch_Config->choice.setup = NULLP;
4205    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4206    if(!dlBwp->pdsch_Config->choice.setup)
4207    {
4208       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4209       return RFAILED;
4210    }
4211
4212    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4213    {
4214       return RFAILED;
4215    }
4216
4217    dlBwp->sps_Config = NULLP;
4218    dlBwp->radioLinkMonitoringConfig = NULLP;
4219    return ROK;
4220 }
4221
4222 /*******************************************************************
4223  *
4224  * @brief Builds DMRS UL Pusch Mapping type A
4225  *
4226  * @details
4227  *
4228  *    Function : BuildDMRSULPuschMapTypeA
4229  *
4230  *    Functionality: Builds DMRS UL Pusch Mapping type A
4231  *
4232  * @params[in]
4233  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4234  * @return ROK     - success
4235  *         RFAILED - failure
4236  *
4237  * ****************************************************************/
4238    uint8_t BuildDMRSULPuschMapTypeA
4239 (
4240  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4241  )
4242 {
4243    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4244    dmrsUlCfg->choice.setup= NULLP;
4245    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4246    if(!dmrsUlCfg->choice.setup)
4247    {
4248       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4249       return RFAILED;
4250    }
4251
4252    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4253    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4254    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4255    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4256    {
4257       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4258       return RFAILED;
4259    }
4260    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4261
4262    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4263    dmrsUlCfg->choice.setup->maxLength = NULLP;
4264    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4265    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4266          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4267    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4268    {
4269       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4270       return RFAILED;
4271    }
4272
4273    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4274    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4275          sizeof(long));
4276    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4277    {
4278       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4279       return RFAILED;
4280    }
4281    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4282
4283    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4284    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4285    return ROK;
4286 }
4287
4288 /*******************************************************************
4289  *
4290  * @brief Build PUSCH time domain allocation list
4291  *
4292  * @details
4293  *
4294  *    Function : BuildPuschTimeDomAllocList
4295  *
4296  *    Functionality: Build PUSCH time domain allocation list
4297  *
4298  * @params[in]
4299  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4300  *
4301  * @return ROK     - success
4302  *         RFAILED - failure
4303  *
4304  * ****************************************************************/
4305    uint8_t BuildPuschTimeDomAllocList
4306 (
4307  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4308  )
4309 {
4310    uint8_t idx;
4311    uint8_t elementCnt;
4312    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4313
4314    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4315    timeDomAllocList->choice.setup = NULLP;
4316    CU_ALLOC(timeDomAllocList->choice.setup, \
4317          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4318    if(!timeDomAllocList->choice.setup)
4319    {
4320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4321       return RFAILED;
4322    }
4323
4324    elementCnt = 2;
4325    timeDomAllocList->choice.setup->list.count = elementCnt;
4326    timeDomAllocList->choice.setup->list.size = \
4327                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4328    timeDomAllocList->choice.setup->list.array = NULLP;
4329    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4330          timeDomAllocList->choice.setup->list.size);
4331    if(!timeDomAllocList->choice.setup->list.array)
4332    {
4333       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4334       return RFAILED;
4335    }
4336
4337    for(idx = 0; idx < elementCnt; idx++)
4338    {
4339       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4340       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4341             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4342       if(!timeDomAllocList->choice.setup->list.array[idx])
4343       {
4344          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4345          return RFAILED;
4346       }
4347    }
4348
4349    idx = 0;
4350    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4351    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4352    if(!timeDomAlloc->k2)
4353    {
4354       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4355       return RFAILED;
4356    }
4357    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4358    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4359    timeDomAlloc->startSymbolAndLength = 66;
4360
4361    idx++;
4362    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4363    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4364    if(!timeDomAlloc->k2)
4365    {
4366        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4367        return RFAILED;
4368    }
4369    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4370    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4371    timeDomAlloc->startSymbolAndLength = 66;
4372
4373    return ROK;
4374 }
4375
4376 /*******************************************************************
4377  *
4378  * @brief Builds BWP UL dedicated PUSCH Config
4379  *
4380  * @details
4381  *
4382  *    Function : BuildBWPUlDedPuschCfg
4383  *
4384  *    Functionality:
4385  *      Builds BWP UL dedicated PUSCH Config
4386  *
4387  * @params[in] : PUSCH_Config_t *puschCfg
4388  *
4389  * @return ROK     - success
4390  *         RFAILED - failure
4391  *
4392  * ****************************************************************/
4393 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4394 {
4395    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4396    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4397    if(!puschCfg->dataScramblingIdentityPUSCH)
4398    {
4399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4400       return RFAILED;
4401    }
4402    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4403
4404    puschCfg->txConfig = NULLP;
4405    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4406    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4407          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4408    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4409    {
4410       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4411       return RFAILED;
4412    }
4413
4414    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4415    {
4416       return RFAILED;
4417    }
4418
4419    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4420    puschCfg->pusch_PowerControl = NULLP;
4421    puschCfg->frequencyHopping = NULLP;
4422    puschCfg->frequencyHoppingOffsetLists = NULLP;
4423    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4424
4425    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4426    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4427          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4428    if(!puschCfg->pusch_TimeDomainAllocationList)
4429    {
4430       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4431       return RFAILED;
4432    }
4433
4434    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4435    {
4436       return RFAILED;
4437    }
4438
4439    puschCfg->pusch_AggregationFactor = NULLP;
4440    puschCfg->mcs_Table = NULLP;
4441    puschCfg->mcs_TableTransformPrecoder = NULLP;
4442    puschCfg->transformPrecoder = NULLP;
4443    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4444    if(!puschCfg->transformPrecoder)
4445    {
4446       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4447       return RFAILED;
4448    }
4449    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4450
4451    puschCfg->codebookSubset = NULLP;
4452    puschCfg->maxRank = NULLP;
4453    puschCfg->rbg_Size = NULLP;
4454    puschCfg->uci_OnPUSCH = NULLP;
4455    puschCfg->tp_pi2BPSK = NULLP;
4456
4457    return ROK;
4458 }
4459
4460 /*******************************************************************
4461  *
4462  * @brief Builds BWP UL dedicated PUCCH Config
4463  *
4464  * @details
4465  *
4466  *    Function : BuildBWPUlDedPucchCfg
4467  *
4468  *    Functionality:
4469  *      Builds BWP UL dedicated PUCCH Config
4470  *
4471  * @params[in] : PUCCH_Config_t *pucchCfg
4472  *
4473  * @return ROK     - success
4474  *         RFAILED - failure
4475  *
4476  * ****************************************************************/
4477 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4478 {
4479    uint8_t arrIdx, elementCnt;
4480    uint8_t rsrcIdx, rsrcSetIdx;
4481    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4482    PUCCH_Resource_t *rsrc = NULLP;
4483
4484    //RESOURCE SET
4485    elementCnt = 1;
4486    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4487    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4488    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4489    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4490    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4491    {
4492       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4493    }
4494    rsrcSetIdx = 0;
4495    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4496    rsrcSet->pucch_ResourceSetId = 1;
4497    elementCnt = 1;
4498    rsrcSet->resourceList.list.count = elementCnt;
4499    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4500    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4501    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4502    {
4503       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4504    }
4505    rsrcIdx = 0;
4506    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4507
4508    //RESOURCE
4509    elementCnt = 1;
4510    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4511    pucchCfg->resourceToAddModList->list.count = elementCnt;
4512    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4513    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4514    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4515    {
4516       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4517    }
4518    rsrcIdx = 0;
4519    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4520    rsrc->pucch_ResourceId = 1;
4521    rsrc->startingPRB = 0;
4522    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4523    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4524    rsrc->format.choice.format1->initialCyclicShift = 0;
4525    rsrc->format.choice.format1->nrofSymbols = 4;
4526    rsrc->format.choice.format1->startingSymbolIndex = 0;
4527    rsrc->format.choice.format1->timeDomainOCC = 0;
4528
4529    //PUCCH Format 1
4530    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4531    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4532    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4533    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4534    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4535
4536    //DL DATA TO UL ACK
4537    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4538    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4539    {
4540       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4541       return RFAILED;
4542    }
4543
4544    elementCnt = 2;
4545    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4546    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4547    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4548    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4549    {
4550       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4551       return RFAILED;
4552    }
4553
4554    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4555    {
4556       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4557       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4558       {
4559           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4560           return RFAILED;
4561       }
4562    }
4563
4564    arrIdx = 0;
4565    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4566    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4567
4568    return ROK;
4569 }
4570
4571 /*******************************************************************
4572  *
4573  * @brief Fills SRS resource to add/modify list
4574  *
4575  * @details
4576  *
4577  *    Function : BuildSrsRsrcAddModList
4578  *
4579  *    Functionality: Fills SRS resource to add/modify list
4580  *
4581  * @params[in]
4582  * @return ROK     - success
4583  *         RFAILED - failure
4584  *
4585  * ****************************************************************/
4586 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4587 {
4588    uint8_t   elementCnt;
4589    uint8_t   rsrcIdx;
4590
4591    elementCnt = 1;
4592    resourceList->list.count = elementCnt;
4593    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4594    resourceList->list.array = NULLP;
4595    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4596    if(!resourceList->list.array)
4597    {
4598       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4599       return RFAILED;
4600    }
4601
4602    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4603    {
4604       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4605       if(!resourceList->list.array[rsrcIdx])
4606       {
4607          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4608          return RFAILED;
4609       }
4610    }
4611
4612    rsrcIdx = 0;
4613    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4614    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4615    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4616
4617    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4618    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4619          sizeof(struct SRS_Resource__transmissionComb__n2));
4620    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4621    {
4622       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4623       return RFAILED;
4624    }
4625    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4626       = SRS_COMB_OFFSET_N2;
4627    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4628       = SRS_CYCLIC_SHIFT_N2;
4629
4630    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4631    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4632                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4633    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4634                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4635
4636    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4637    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4638    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4639    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4640    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4641    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4642                                                                SRS_Resource__groupOrSequenceHopping_neither;
4643
4644    /* Setting resource type to aperiodic for intergration purposes */
4645    resourceList->list.array[rsrcIdx]->resourceType.present = \
4646                                                              SRS_Resource__resourceType_PR_aperiodic;
4647    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4648    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4649          sizeof(struct SRS_Resource__resourceType__aperiodic));
4650    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4651    {
4652       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4653       return RFAILED;
4654    }
4655    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4656
4657    return ROK;
4658 }
4659
4660 /*******************************************************************
4661  *
4662  * @brief Build SRS resource set Add/mod list
4663  *
4664  * @details
4665  *
4666  *    Function : BuildSrsRsrcSetAddModList
4667  *
4668  *    Functionality: Build SRS resource set Add/mod list
4669  *
4670  * @params[in]
4671  * @return ROK     - success
4672  *         RFAILED - failure
4673  *
4674  * ****************************************************************/
4675    uint8_t BuildSrsRsrcSetAddModList
4676 (
4677  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4678  )
4679 {
4680    uint8_t  elementCnt;
4681    uint8_t  rSetIdx;
4682    uint8_t  rsrcIdx;
4683    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4684
4685    elementCnt = 1;
4686    rsrcSetList->list.count = elementCnt;
4687    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4688    rsrcSetList->list.array = NULLP;
4689    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4690    if(!rsrcSetList->list.array)
4691    {
4692       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4693       return RFAILED;
4694    }
4695
4696    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4697    {
4698       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4699       if(!rsrcSetList->list.array[rSetIdx])
4700       {
4701          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4702          return RFAILED;
4703       }
4704    }
4705
4706    rSetIdx = 0;
4707    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4708
4709    /* Fill Resource Id list in resource set */
4710    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4711    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4712          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4713    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4714    {
4715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4716       return RFAILED;
4717    }
4718
4719    elementCnt = 1;
4720    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4721    rsrcIdList->list.count = elementCnt;
4722    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4723    rsrcIdList->list.array = NULLP;
4724    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4725    if(!rsrcIdList->list.array)
4726    {
4727       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4728       return RFAILED;
4729    }
4730
4731    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4732    {
4733       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4734       if(!rsrcIdList->list.array[rsrcIdx])
4735       {
4736          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4737          return RFAILED;
4738       }
4739    }
4740
4741    rsrcIdx = 0;
4742    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4743
4744    /* Fill resource type */
4745    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4746                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4747
4748    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4749    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4750          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4751    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4752    {
4753       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4754       return RFAILED;
4755    }
4756    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4757       = APERIODIC_SRS_RESRC_TRIGGER;
4758
4759    /* TODO : Fill values for below IEs as expected by Viavi */
4760    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4761    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4762
4763
4764    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4765    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4766    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4767    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4768    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4769
4770    return ROK;
4771 }
4772
4773 /*******************************************************************
4774  *
4775  * @brief Builds BWP UL dedicated SRS Config
4776  *
4777  * @details
4778  *
4779  *    Function : BuildBWPUlDedSrsCfg
4780  *
4781  *    Functionality: Builds BWP UL dedicated SRS Config
4782  *
4783  * @params[in] SRS Config
4784  * @return ROK     - success
4785  *         RFAILED - failure
4786  *
4787  * ****************************************************************/
4788 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4789 {
4790    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4791    srsCfg->srs_ResourceSetToAddModList = NULLP;
4792    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4793          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4794    if(!srsCfg->srs_ResourceSetToAddModList)
4795    {
4796       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4797       return RFAILED;
4798    }
4799    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4800    {
4801       return RFAILED;
4802    }
4803
4804    srsCfg->srs_ResourceToReleaseList = NULLP;
4805
4806    /* Resource to Add/Modify list */
4807    srsCfg->srs_ResourceToAddModList = NULLP;
4808    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4809          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4810    if(!srsCfg->srs_ResourceToAddModList)
4811    {
4812       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4813       return RFAILED;
4814    }
4815
4816    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4817    {
4818       return RFAILED;
4819    }
4820
4821    srsCfg->tpc_Accumulation = NULLP;
4822
4823    return ROK;
4824 }
4825
4826 /*******************************************************************
4827  *
4828  * @brief Builds inital UL BWP
4829  *
4830  * @details
4831  *
4832  *    Function : BuildInitialUlBWP
4833  *
4834  *    Functionality: Builds initial UL BWP
4835  *
4836  * @params[in] BWP_UplinkDedicated_t *ulBwp
4837  * @return ROK     - success
4838  *         RFAILED - failure
4839  *
4840  * ****************************************************************/
4841 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4842 {
4843    ulBwp->pucch_Config = NULLP;
4844    ulBwp->pucch_Config = NULLP;
4845    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4846    if(!ulBwp->pucch_Config)
4847    {
4848       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4849       return RFAILED;
4850    }
4851
4852    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4853    ulBwp->pucch_Config->choice.setup = NULLP;
4854    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4855    if(!ulBwp->pucch_Config->choice.setup)
4856    {
4857       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4858       return RFAILED;
4859    }
4860
4861    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4862    {
4863       return RFAILED;
4864    }
4865
4866    /* Fill BWP UL dedicated PUSCH config */
4867    ulBwp->pusch_Config = NULLP;
4868    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4869    if(!ulBwp->pusch_Config)
4870    {
4871       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4872       return RFAILED;
4873    }
4874
4875    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4876    ulBwp->pusch_Config->choice.setup = NULLP;
4877    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4878    if(!ulBwp->pusch_Config->choice.setup)
4879    {
4880       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4881       return RFAILED;
4882    }
4883
4884    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4885    {
4886       return RFAILED;
4887    }
4888
4889    ulBwp->configuredGrantConfig = NULLP;
4890
4891    /* Fill BPW UL dedicated SRS config */
4892    ulBwp->srs_Config = NULLP;
4893    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4894    if(!ulBwp->srs_Config)
4895    {
4896       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4897       return RFAILED;
4898    }
4899
4900    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4901    ulBwp->srs_Config->choice.setup = NULLP;
4902    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4903    if(!ulBwp->srs_Config->choice.setup)
4904    {
4905       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4906       return RFAILED;
4907    }
4908
4909    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4910    {
4911       return RFAILED;
4912    }
4913
4914    ulBwp->beamFailureRecoveryConfig = NULLP;
4915
4916    return ROK;
4917 }
4918
4919 /*******************************************************************
4920  *
4921  * @brief Builds Pusch Serving cell Config
4922  *
4923  * @details
4924  *
4925  *    Function : BuildPuschSrvCellCfg
4926  *
4927  *    Functionality: Builds Pusch Serving cell Config
4928  *
4929  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4930  *
4931  * @return ROK     - success
4932  *         RFAILED - failure
4933  *
4934  * ****************************************************************/
4935 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4936 {
4937    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4938    puschCfg->choice.setup = NULLP;
4939    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4940    if(!puschCfg->choice.setup)
4941    {
4942       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4943       return RFAILED;
4944    }
4945
4946    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4947    puschCfg->choice.setup->rateMatching = NULLP;
4948    puschCfg->choice.setup->xOverhead = NULLP;
4949    puschCfg->choice.setup->ext1 = NULLP;
4950    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4951    if(!puschCfg->choice.setup->ext1)
4952    {
4953       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4954       return RFAILED;
4955    }
4956
4957    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4958    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4959    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4960    {
4961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4962       return RFAILED;
4963    }
4964    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4965
4966    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4967    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4968    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4969    {
4970       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4971       return RFAILED;
4972    }
4973    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4974    return ROK;
4975 }
4976
4977 /*******************************************************************
4978  *
4979  * @brief Builds UL config
4980  * @details
4981  *
4982  *    Function : BuildUlCfg
4983  *
4984  *    Functionality: Builds UL config in spCellCfgDed
4985  *
4986  * @params[in] UplinkConfig_t *ulCfg
4987  *
4988  * @return ROK     - success
4989  *         RFAILED - failure
4990  *
4991  * ****************************************************************/
4992 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4993 {
4994    ulCfg->initialUplinkBWP = NULLP;
4995    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4996    if(!ulCfg->initialUplinkBWP)
4997    {
4998       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4999       return RFAILED;
5000    }
5001
5002    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
5003    {
5004       return RFAILED;
5005    }
5006
5007    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5008    ulCfg->uplinkBWP_ToAddModList = NULLP;
5009    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5010    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5011    if(!ulCfg->firstActiveUplinkBWP_Id)
5012    {
5013       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5014       return RFAILED;
5015    }
5016    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5017
5018    ulCfg->pusch_ServingCellConfig = NULLP;
5019    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
5020          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5021    if(!ulCfg->pusch_ServingCellConfig)
5022    {
5023       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5024       return RFAILED;
5025    }
5026
5027    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5028    {
5029       return RFAILED;
5030    }
5031
5032    ulCfg->carrierSwitching = NULLP;
5033    ulCfg->ext1 = NULLP;
5034    return ROK;
5035 }
5036
5037 /*******************************************************************
5038  *
5039  * @brief Builds PDSCH serving cell config
5040  * @details
5041  *
5042  *    Function : BuildPdschSrvCellCfg
5043  *
5044  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5045  *
5046  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5047  *
5048  * @return ROK     - success
5049  *         RFAILED - failure
5050  *
5051  * ****************************************************************/
5052 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5053 {
5054    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5055    pdschCfg->choice.setup = NULLP;
5056    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5057    if(!pdschCfg->choice.setup)
5058    {
5059       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5060       return RFAILED;
5061    }
5062
5063    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5064    pdschCfg->choice.setup->xOverhead = NULLP;
5065    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5066    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5067    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5068    {
5069       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5070       return RFAILED;
5071    }
5072    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5073    pdschCfg->choice.setup->pucch_Cell = NULLP;
5074    pdschCfg->choice.setup->ext1 = NULLP;
5075
5076    return ROK;
5077 }
5078
5079 /*******************************************************************
5080  *
5081  * @brief Builds CSI Meas config
5082  * @details
5083  *
5084  *    Function : BuildCsiMeasCfg
5085  *
5086  *    Functionality: Builds CSI Meas config in spCellCfgDed
5087  *
5088  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5089  *
5090  * @return ROK     - success
5091  *         RFAILED - failure
5092  *
5093  * ****************************************************************/
5094 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5095 {
5096
5097    return ROK;
5098 }
5099
5100 /*******************************************************************
5101  *
5102  * @brief Builds Spcell config dedicated
5103  * @details
5104  *
5105  *    Function : BuildSpCellCfgDed
5106  *
5107  *    Functionality: Builds sp cell config dedicated in spCellCfg
5108  *
5109  * @params[in] ServingCellConfig_t srvCellCfg
5110  *
5111  * @return ROK     - success
5112  *         RFAILED - failure
5113  *
5114  * ****************************************************************/
5115 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5116 {
5117    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5118
5119    srvCellCfg->initialDownlinkBWP = NULLP;
5120    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5121    if(!srvCellCfg->initialDownlinkBWP)
5122    {
5123       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5124       return RFAILED;
5125    }
5126
5127    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5128    {
5129       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5130       return RFAILED;
5131    }
5132    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5133    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5134
5135    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5136    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5137    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5138    {
5139       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5140       return RFAILED;
5141    }
5142    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5143
5144    srvCellCfg->bwp_InactivityTimer = NULLP;
5145
5146    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5147    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5148    if(!srvCellCfg->defaultDownlinkBWP_Id)
5149    {
5150       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5151       return RFAILED;
5152    }
5153    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5154
5155    srvCellCfg->uplinkConfig = NULLP;
5156    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5157    if(!srvCellCfg->uplinkConfig)
5158    {
5159       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5160       return RFAILED;
5161    }
5162
5163    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5164    {
5165       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5166       return RFAILED;
5167    }
5168    srvCellCfg->supplementaryUplink = NULLP;
5169    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5170
5171    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5172    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5173    if(!srvCellCfg->pdsch_ServingCellConfig)
5174    {
5175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5176       return RFAILED;
5177    }
5178
5179    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5180    {
5181       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5182       return RFAILED;
5183    }
5184
5185    srvCellCfg->csi_MeasConfig = NULLP;
5186 #if 0
5187    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5188       if(!srvCellCfg->csi_MeasConfig)
5189       {
5190          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5191          return RFAILED;
5192       }
5193
5194    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5195    {
5196       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5197       return RFAILED;
5198    }
5199 #endif
5200    srvCellCfg->sCellDeactivationTimer = NULLP;
5201    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5202    srvCellCfg->tag_Id = TAG_ID;
5203    srvCellCfg->dummy = NULLP;
5204    srvCellCfg->pathlossReferenceLinking = NULLP;
5205    srvCellCfg->servingCellMO = NULLP;
5206    srvCellCfg->ext1 = NULLP;
5207
5208    return ROK;
5209 }
5210 /*******************************************************************
5211  *
5212  * @brief Builds Spcell config
5213  *
5214  * @details
5215  *
5216  *    Function : BuildSpCellCfg
5217  *
5218  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5219  *
5220  * @params[in] SpCellConfig_t spCellCfg
5221  *
5222  * @return ROK     - success
5223  *         RFAILED - failure
5224  *
5225  * ****************************************************************/
5226 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5227 {
5228
5229    spCellCfg->servCellIndex = NULLP;
5230    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5231    if(!spCellCfg->servCellIndex)
5232    {
5233       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5234       return RFAILED;
5235    }
5236    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5237
5238    spCellCfg->reconfigurationWithSync = NULLP;
5239    spCellCfg->rlf_TimersAndConstants = NULLP;
5240    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5241    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5242    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5243    {
5244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5245       return RFAILED;
5246    }
5247    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5248
5249    spCellCfg->spCellConfigDedicated = NULLP;
5250    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5251    if(!spCellCfg->spCellConfigDedicated)
5252    {
5253       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5254       return RFAILED;
5255    }
5256    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5257    {
5258       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5259       return RFAILED;
5260    }
5261    return ROK;
5262 }
5263 /*******************************************************************
5264  *
5265  * @brief Builds Phy cell group config
5266  *
5267  * @details
5268  *
5269  *    Function : BuildPhyCellGrpCfg
5270  *
5271  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5272  *
5273  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5274  *
5275  * @return ROK     - success
5276  *         RFAILED - failure
5277  *
5278  * ****************************************************************/
5279 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5280 {
5281    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5282    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5283
5284    phyCellGrpCfg->p_NR_FR1 = NULLP;
5285    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5286    if(!phyCellGrpCfg->p_NR_FR1)
5287    {
5288       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5289       return RFAILED;
5290    }
5291    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5292    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5293    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5294    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5295    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5296    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5297    phyCellGrpCfg->cs_RNTI = NULLP;
5298    phyCellGrpCfg->ext1 = NULLP;
5299    phyCellGrpCfg->ext2 = NULLP;
5300
5301    return ROK;
5302 }
5303
5304 /*******************************************************************
5305  *
5306  * @brief Builds tag config
5307  *
5308  * @details
5309  *
5310  *    Function : BuildTagConfig
5311  *
5312  *    Functionality: Builds tag config in MacCellGroupConfig
5313  *
5314  * @params[in] TAG_Config *tag_Config
5315  *
5316  * @return ROK     - success
5317  *         RFAILED - failure
5318  *
5319  * ****************************************************************/
5320 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5321 {
5322    struct TAG_Config__tag_ToAddModList *tagList;
5323    uint8_t                     idx, elementCnt;
5324
5325    tagConfig->tag_ToReleaseList = NULLP;
5326    tagConfig->tag_ToAddModList = NULLP;
5327    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5328    if(!tagConfig->tag_ToAddModList)
5329    {
5330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5331       return RFAILED;
5332    }
5333
5334    elementCnt = 1; //ODU_VALUE_ONE;
5335    tagList = tagConfig->tag_ToAddModList;
5336    tagList->list.count = elementCnt;
5337    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5338
5339    tagList->list.array = NULLP;
5340    CU_ALLOC(tagList->list.array, tagList->list.size);
5341    if(!tagList->list.array)
5342    {
5343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5344       return RFAILED;
5345    }
5346
5347    for(idx=0; idx<tagList->list.count; idx++)
5348    {
5349       tagList->list.array[idx] = NULLP;
5350       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5351       if(!tagList->list.array[idx])
5352       {
5353          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5354          return RFAILED;
5355       }
5356    }
5357
5358    idx = 0;
5359    tagList->list.array[idx]->tag_Id = TAG_ID;
5360    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5361
5362    return ROK;
5363 }
5364
5365 /*******************************************************************
5366  *
5367  * @brief Builds PHR Config
5368  *
5369  * @details
5370  *
5371  *    Function : BuildPhrConfig
5372  *
5373  *    Functionality: Builds phrConfig in MacCellGroupConfig
5374  *
5375  * @params[in] PHR Config *
5376  *
5377  * @return ROK     - success
5378  *         RFAILED - failure
5379  *
5380  * ****************************************************************/
5381 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5382 {
5383
5384    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5385    phrConfig->choice.setup = NULLP;
5386    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5387    if(!phrConfig->choice.setup)
5388    {
5389       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5390       return RFAILED;
5391    }
5392
5393    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5394    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5395    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5396    phrConfig->choice.setup->multiplePHR              = false;
5397    phrConfig->choice.setup->dummy                    = false;
5398    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5399    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5400
5401    return ROK;
5402 }
5403
5404 /*******************************************************************
5405  *
5406  * @brief Builds BSR Config
5407  *
5408  * @details
5409  *
5410  *    Function : BuildBsrConfig
5411  *
5412  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5413  *
5414  * @params[in] BSR_Config *bsrConfig
5415  *
5416  * @return ROK     - success
5417  *         RFAILED - failure
5418  *
5419  * ****************************************************************/
5420 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5421 {
5422    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5423    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5424    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5425
5426    return ROK;
5427 }
5428
5429 /*******************************************************************
5430  *
5431  * @brief Builds scheduling request config
5432  *
5433  * @details
5434  *
5435  *    Function : BuildSchedulingReqConfig
5436  *
5437  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5438  *
5439  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5440  *
5441  * @return ROK     - success
5442  *         RFAILED - failure
5443  *
5444  * ****************************************************************/
5445 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5446 {
5447    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5448    uint8_t                     idx, elementCnt;
5449
5450    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5451    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5452          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5453    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5454    {
5455       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5456       return RFAILED;
5457    }
5458
5459    elementCnt = 1; //ODU_VALUE_ONE;
5460    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5461    schReqList->list.count = elementCnt;
5462    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5463
5464    schReqList->list.array = NULLP;
5465    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5466    if(!schReqList->list.array)
5467    {
5468       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5469       return RFAILED;
5470    }
5471
5472    for(idx=0;idx<schReqList->list.count; idx++)
5473    {
5474       schReqList->list.array[idx] = NULLP;
5475       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5476       if(!schReqList->list.array[idx])
5477       {
5478          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5479          return RFAILED;
5480       }
5481    }
5482
5483    idx = 0;
5484    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5485
5486    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5487    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5488    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5489    {
5490       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5491       return RFAILED;
5492    }
5493    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5494    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5495    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5496
5497    return ROK;
5498 }
5499 /*******************************************************************
5500  *
5501  * @brief Builds Mac cell group config
5502  *
5503  * @details
5504  *
5505  *    Function : BuildMacCellGrpCfg
5506  *
5507  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5508  *
5509  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5510  *
5511  * @return ROK     - success
5512  *         RFAILED - failure
5513  *
5514  * ****************************************************************/
5515 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5516 {
5517    macCellGrpCfg->drx_ConfigRrc = NULLP;
5518    macCellGrpCfg->schedulingRequestConfig = NULLP;
5519    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5520    if(!macCellGrpCfg->schedulingRequestConfig)
5521    {
5522       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5523       return RFAILED;
5524    }
5525
5526    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5527    {
5528       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5529       return RFAILED;
5530    }
5531
5532    macCellGrpCfg->bsr_Config = NULLP;
5533    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5534    if(!macCellGrpCfg->bsr_Config)
5535    {
5536       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5537       return RFAILED;
5538    }
5539
5540    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5541    {
5542       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5543       return RFAILED;
5544    }
5545
5546    macCellGrpCfg->tag_Config = NULLP;
5547    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5548    if(!macCellGrpCfg->tag_Config)
5549    {
5550       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5551       return RFAILED;
5552    }
5553
5554    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5555    {
5556       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5557       return RFAILED;
5558    }
5559
5560    macCellGrpCfg->phr_Config = NULLP;
5561    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5562    if(!macCellGrpCfg->phr_Config)
5563    {
5564       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5565       return RFAILED;
5566    }
5567
5568    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5569    {
5570       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5571       return RFAILED;
5572    }
5573
5574    macCellGrpCfg->skipUplinkTxDynamic = false;
5575    macCellGrpCfg->ext1 = NULLP;
5576
5577    return ROK;
5578 }
5579 /*******************************************************************
5580  *
5581  * @brief Frees memeory allocated for SearchSpcToAddModList
5582  *
5583  * @details
5584  *
5585  *    Function : FreeSearchSpcToAddModList
5586  *
5587  *    Functionality: Deallocating memory of SearchSpcToAddModList
5588  *
5589  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5590  *
5591  * @return void
5592  *
5593  4221 * ****************************************************************/
5594 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5595 {
5596    uint8_t idx1=0;
5597    uint8_t idx2=0;
5598    struct  SearchSpace *searchSpc=NULLP;
5599
5600    if(searchSpcList->list.array)
5601    {
5602       if(searchSpcList->list.array[idx2])
5603       {
5604          searchSpc = searchSpcList->list.array[idx2];
5605          if(searchSpc->controlResourceSetId)
5606          {
5607             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5608             {
5609                if(searchSpc->monitoringSymbolsWithinSlot)
5610                {
5611                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5612                   {
5613                      if(searchSpc->nrofCandidates)
5614                      {
5615                         if(searchSpc->searchSpaceType)
5616                         {
5617                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5618                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5619                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5620                                     SearchSpace__searchSpaceType));
5621                         }
5622                         CU_FREE(searchSpc->nrofCandidates,
5623                               sizeof(struct SearchSpace__nrofCandidates));
5624                      }
5625                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5626                            searchSpc->monitoringSymbolsWithinSlot->size);
5627                   }
5628                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5629                         sizeof(BIT_STRING_t));
5630                }
5631                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5632                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5633             }
5634             CU_FREE(searchSpc->controlResourceSetId,
5635                   sizeof(ControlResourceSetId_t));
5636          }
5637       }
5638       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5639       {
5640          CU_FREE(searchSpcList->list.array[idx1],
5641                sizeof(struct SearchSpace));
5642       }
5643       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5644    }
5645 }
5646 /*******************************************************************
5647  *
5648  * @brief Frees memory allocated for PdschTimeDomAllocList
5649  *
5650  * @details
5651  *
5652  *    Function : FreePdschTimeDomAllocList
5653  *
5654  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5655  *
5656  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5657  *
5658  * @return void
5659  *
5660  4221 * ****************************************************************/
5661 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5662 {
5663    uint8_t idx1=0;
5664
5665    if(timeDomAllocList->choice.setup)
5666    {
5667       if(timeDomAllocList->choice.setup->list.array)
5668       {
5669          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5670          {
5671             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5672                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5673          }
5674          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5675                timeDomAllocList->choice.setup->list.size);
5676       }
5677       CU_FREE(timeDomAllocList->choice.setup,\
5678             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5679    }
5680 }
5681 /*******************************************************************
5682  *
5683  * @brief Frees memory allocated for PuschTimeDomAllocList
5684  *
5685  *@details
5686  *
5687  *    Function : FreePuschTimeDomAllocList
5688  *
5689  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5690  *
5691  * @params[in] PUSCH_Config_t *puschCfg
5692  *
5693  * @return void
5694  *
5695  ***********************************************************************/
5696 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5697 {
5698    uint8_t idx1=0;
5699    uint8_t idx2=0;
5700    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5701
5702    if(puschCfg->pusch_TimeDomainAllocationList)
5703    {
5704       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5705       if(timeDomAllocList_t->choice.setup)
5706       {
5707          if(timeDomAllocList_t->choice.setup->list.array)
5708          {
5709             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5710             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5711             {
5712                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5713                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5714             }
5715             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5716                   timeDomAllocList_t->choice.setup->list.size);
5717          }
5718          CU_FREE(timeDomAllocList_t->choice.setup, \
5719                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5720       }
5721       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5722       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5723             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5724    }
5725
5726 }
5727
5728 /*******************************************************************
5729  *
5730  * @brief Frees memory allocated for Dedicated PUCCH config
5731  *
5732  * @details
5733  *
5734  *    Function : FreeBWPUlDedPucchCfg
5735  *
5736  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5737  *
5738  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5739  *
5740  * @return void
5741  *
5742  * ****************************************************************/
5743 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5744 {
5745    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5746    PUCCH_Config_t *pucchCfg = NULLP;
5747    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5748    PUCCH_Resource_t *rsrc = NULLP;
5749
5750    if(ulBwpPucchCfg)
5751    {
5752       if(ulBwpPucchCfg->choice.setup)
5753       {
5754          pucchCfg = ulBwpPucchCfg->choice.setup;
5755
5756          //Free resource set list
5757          if(pucchCfg->resourceSetToAddModList)
5758          {
5759             if(pucchCfg->resourceSetToAddModList->list.array)
5760             {
5761                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5762                {
5763                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5764                   if(rsrcSet->resourceList.list.array)
5765                   {
5766                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5767                      {
5768                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5769                      }
5770                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5771                   }
5772                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5773                }
5774                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5775             }
5776             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5777          }
5778
5779          //Free resource list
5780          if(pucchCfg->resourceToAddModList)
5781          {
5782             if(pucchCfg->resourceToAddModList->list.array)
5783             {
5784                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5785                {
5786                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5787                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5788                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5789                }
5790                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5791             }
5792             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5793          }
5794
5795          //PUCCH Format 1
5796          if(pucchCfg->format1)
5797          {
5798             if(pucchCfg->format1->choice.setup)
5799             {
5800                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5801                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5802             }
5803             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5804          }
5805
5806          //DL DATA TO UL ACK
5807          if(pucchCfg->dl_DataToUL_ACK)
5808          {
5809             if(pucchCfg->dl_DataToUL_ACK->list.array)
5810             {
5811                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5812                {
5813                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5814                }
5815                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5816             }
5817             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5818          }
5819
5820          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5821       }
5822       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5823    }
5824 }
5825
5826 /*******************************************************************
5827  *
5828  * @brief Frees memory allocated for InitialUlBWP
5829  *
5830  * @details
5831  *
5832  *    Function : FreeInitialUlBWP
5833  *
5834  *    Functionality: Deallocating memory of InitialUlBWP
5835  *
5836  * @params[in] BWP_UplinkDedicated_t *ulBwp
5837  *
5838  * @return void
5839  *
5840  * ****************************************************************/
5841 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5842 {
5843    uint8_t  rSetIdx, rsrcIdx;
5844    SRS_Config_t   *srsCfg = NULLP;
5845    PUSCH_Config_t *puschCfg = NULLP;
5846    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5847    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5848    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5849    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5850
5851    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5852
5853    if(ulBwp->pusch_Config)
5854    {
5855       if(ulBwp->pusch_Config->choice.setup)
5856       {
5857          puschCfg=ulBwp->pusch_Config->choice.setup;
5858          if(puschCfg->dataScramblingIdentityPUSCH)
5859          {
5860             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5861             {
5862                FreePuschTimeDomAllocList(puschCfg);
5863                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5864                if(dmrsUlCfg->choice.setup)
5865                {
5866                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5867                   {
5868                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5869                      {
5870                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5871                               sizeof(long));
5872                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5873                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5874                      }
5875                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5876                            sizeof(long));
5877                   }
5878                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5879                }
5880                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5881                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5882             }
5883             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5884          }
5885          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5886       }
5887       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5888
5889       /* Free SRS-Config */
5890       if(ulBwp->srs_Config)
5891       {
5892          if(ulBwp->srs_Config->choice.setup)
5893          {
5894             srsCfg = ulBwp->srs_Config->choice.setup;
5895
5896             /* Free Resource Set to add/mod list */
5897             if(srsCfg->srs_ResourceSetToAddModList)
5898             {
5899                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5900                if(rsrcSetList->list.array)
5901                {
5902                   rSetIdx = 0;
5903
5904                   /* Free SRS resource Id list in this SRS resource set */
5905                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5906                   {
5907                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5908
5909                      if(rsrcIdList->list.array)
5910                      {
5911                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5912                         {
5913                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5914                         }
5915                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5916                      }
5917                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5918                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5919                   }
5920
5921                   /* Free resource type info for this SRS resource set */
5922                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5923                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5924
5925                   /* Free memory for each resource set */
5926                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5927                   {
5928                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5929                   }
5930                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5931                }
5932                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5933                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5934             }
5935
5936             /* Free resource to add/modd list */
5937             if(srsCfg->srs_ResourceToAddModList)
5938             {
5939                resourceList = srsCfg->srs_ResourceToAddModList;
5940                if(resourceList->list.array)
5941                {
5942                   rsrcIdx = 0;
5943                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5944                         sizeof(struct SRS_Resource__transmissionComb__n2));
5945                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5946                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5947
5948                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5949                   {
5950                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5951                   }
5952                   CU_FREE(resourceList->list.array, resourceList->list.size);
5953                }
5954                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5955                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5956             }
5957
5958             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5959          }
5960          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5961       }
5962    }
5963 }
5964 /*******************************************************************
5965  *
5966  * @brief Frees memory allocated for initialUplinkBWP
5967  *
5968  * @details
5969  *
5970  *    Function : FreeinitialUplinkBWP
5971  *
5972  *    Functionality: Deallocating memory of initialUplinkBWP
5973  *
5974  * @params[in] UplinkConfig_t *ulCfg
5975  *
5976  * @return void
5977  *
5978  *
5979  * ****************************************************************/
5980 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5981 {
5982    BWP_UplinkDedicated_t *ulBwp=NULLP;
5983    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5984
5985    if(ulCfg->initialUplinkBWP)
5986    {
5987       ulBwp=ulCfg->initialUplinkBWP;
5988       if(ulCfg->firstActiveUplinkBWP_Id)
5989       {
5990          if(ulCfg->pusch_ServingCellConfig)
5991          {
5992             puschCfg=ulCfg->pusch_ServingCellConfig;
5993             if(puschCfg->choice.setup)
5994             {
5995                if(puschCfg->choice.setup->ext1)
5996                {
5997                   CU_FREE(puschCfg->choice.setup->ext1->\
5998                         processingType2Enabled,sizeof(BOOLEAN_t));
5999                   CU_FREE(puschCfg->choice.setup->ext1->\
6000                         maxMIMO_Layers,sizeof(long));
6001                   CU_FREE(puschCfg->choice.setup->ext1, \
6002                         sizeof(struct PUSCH_ServingCellConfig__ext1));
6003                }
6004                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6005             }
6006             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6007          }
6008          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6009       }
6010       FreeInitialUlBWP(ulBwp);
6011       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6012    }
6013 }
6014 /*******************************************************************
6015  *
6016  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6017  *
6018  * @details
6019  *
6020  *    Function : FreeBWPDlDedPdschCfg
6021  *
6022  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6023  *
6024  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6025  *
6026  * @return void
6027  *
6028  *
6029  * ****************************************************************/
6030 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6031 {
6032    struct PDSCH_Config *pdschCfg=NULLP;
6033    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6034    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6035    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6036
6037    if(dlBwp->pdsch_Config->choice.setup)
6038    {
6039       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6040       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6041       {
6042          if(pdschCfg->pdsch_TimeDomainAllocationList)
6043          {
6044             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6045             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6046             {
6047                prbBndlType=&pdschCfg->prb_BundlingType;
6048                CU_FREE(prbBndlType->choice.staticBundling,\
6049                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6050                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6051             }
6052             FreePdschTimeDomAllocList(timeDomAllocList);
6053             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6054                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6055          }
6056          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6057          if(dmrsDlCfg->choice.setup)
6058          {
6059             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6060                   sizeof(long));
6061             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6062          }
6063          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6064                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6065       }
6066       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6067    }
6068 }
6069 /*******************************************************************
6070  *
6071  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6072  *
6073  * @details
6074  *
6075  *    Function : FreeBWPDlDedPdcchCfg
6076  *
6077  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6078  *
6079  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6080  *
6081  * @return void
6082  *
6083  *
6084  * ****************************************************************/
6085 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6086 {
6087    uint8_t idx1=0;
6088    uint8_t idx2=0;
6089    struct PDCCH_Config *pdcchCfg=NULLP;
6090    struct ControlResourceSet *controlRSet=NULLP;
6091    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6092
6093    if(dlBwp->pdcch_Config->choice.setup)
6094    {
6095       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6096       if(pdcchCfg->controlResourceSetToAddModList)
6097       {
6098          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6099          if(controlRSetList->list.array)
6100          {
6101             controlRSet = controlRSetList->list.array[idx2];
6102             if(controlRSet)
6103             {
6104                if(controlRSet->frequencyDomainResources.buf)
6105                {
6106                   if(controlRSet->pdcch_DMRS_ScramblingID)
6107                   {
6108                      if(pdcchCfg->searchSpacesToAddModList)
6109                      {
6110                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6111                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
6112                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6113                      }
6114                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6115                   }
6116                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
6117                         controlRSet->frequencyDomainResources.size);
6118                }
6119             }
6120             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6121             {
6122                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6123             }
6124             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6125          }
6126          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6127                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6128       }
6129       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6130    }
6131 }
6132 /*******************************************************************
6133  *
6134  * @brief Builds RLC Config
6135  *
6136  * @details
6137  *
6138  *    Function : BuildRlcConfig
6139  *
6140  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
6141  *
6142  * @params[in] RLC_Config *rlcConfig
6143  *
6144  * @return ROK     - success
6145  *         RFAILED - failure
6146  *
6147  * ****************************************************************/
6148 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
6149 {
6150    rlcConfig->present = rlcLcCfgDb.rlcMode;
6151
6152    switch(rlcConfig->present)
6153    {
6154       case RLC_Config_PR_am:
6155          {
6156             rlcConfig->choice.am = NULLP;
6157             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6158             if(!rlcConfig->choice.am)
6159             {
6160                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6161                return RFAILED;
6162             }
6163
6164             /* UL */
6165             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
6166             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6167             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
6168             {
6169                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6170                return RFAILED;
6171             }
6172             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
6173             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
6174             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
6175             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
6176             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
6177
6178             /* DL */
6179             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
6180             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6181             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
6182             {
6183                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6184                return RFAILED;
6185             }
6186             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
6187             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
6188             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
6189
6190             break;
6191          }
6192
6193       case RLC_Config_PR_um_Bi_Directional:
6194          {
6195             rlcConfig->choice.um_Bi_Directional = NULLP;
6196             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
6197             if(!rlcConfig->choice.um_Bi_Directional)
6198             {
6199                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6200                return RFAILED;
6201             }
6202
6203             /* UL */
6204             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
6205             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6206             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
6207             {
6208                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6209                return RFAILED;
6210             }
6211             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
6212
6213             /* DL */
6214             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
6215             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6216             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
6217             {
6218                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6219                return RFAILED;
6220             }
6221             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
6222             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
6223             break;
6224          }
6225    }
6226    return ROK;
6227 }
6228
6229 /*******************************************************************
6230  *
6231  * @brief Builds MAC LC Config
6232  *
6233  * @details
6234  *
6235  *    Function : BuildMacLCConfig
6236  *
6237  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
6238  *
6239  * @params[in] struct LogicalChannelConfig macLcConfig
6240  *
6241  * @return ROK     - success
6242  *         RFAILED - failure
6243  *
6244  * ****************************************************************/
6245 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6246 {
6247
6248    macLcConfig->ul_SpecificParameters = NULLP;
6249    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6250    if(!macLcConfig->ul_SpecificParameters)
6251    {
6252       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6253       return RFAILED;
6254    }
6255
6256    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6257    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6258    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6259    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6260    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6261    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6262    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6263
6264    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6265    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6266    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6267    {
6268       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6269       return RFAILED;
6270    }
6271    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6272
6273    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6274    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6275    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6276    {
6277       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6278       return RFAILED;
6279    }
6280    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6281
6282    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6283    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6284    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6285
6286    return ROK;
6287 }
6288 /*******************************************************************
6289  *
6290  * @brief Builds RLC Bearer to Add/Mod list
6291  *
6292  * @details
6293  *
6294  *    Function :BuildRlcBearerToAddModList
6295  *
6296  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6297  *
6298  * @params[in] rlc_BearerToAddModList
6299  *
6300  * @return ROK     - success
6301  *         RFAILED - failure
6302  *
6303  * ****************************************************************/
6304 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6305 {
6306    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6307
6308    if(updateAllRbCfg)
6309       elementCnt = ueCb->numSrb + ueCb->numDrb;
6310    else
6311    {
6312       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6313       {
6314          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6315             elementCnt++;
6316       }
6317
6318       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6319       {
6320          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6321             elementCnt++;
6322       }
6323    }
6324
6325    if(!elementCnt)
6326    {
6327       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6328       return ROK;
6329    }
6330    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6331    if(!rlcBearerList)
6332    {
6333       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6334       return RFAILED;
6335    }
6336    rlcBearerList->list.count = elementCnt;
6337    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6338
6339    rlcBearerList->list.array = NULLP;
6340    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6341    if(!rlcBearerList->list.array)
6342    {
6343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6344       return RFAILED;
6345    }
6346
6347    for(idx=0; idx<rlcBearerList->list.count; idx++)
6348    {
6349       rlcBearerList->list.array[idx] = NULLP;
6350       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6351       if(!rlcBearerList->list.array[idx])
6352       {
6353          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6354          return RFAILED;
6355       }
6356    }
6357
6358    idx = 0;
6359
6360    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6361    {
6362       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6363          continue;
6364
6365       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6366
6367       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6368       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6369       {
6370          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6371          return RFAILED;
6372       }
6373
6374       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6375       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6376
6377       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6378       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6379       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6380       if(!rlcBearerList->list.array[idx]->rlc_Config)
6381       {
6382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6383          return RFAILED;
6384       }
6385
6386       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6387       {
6388          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6389          return RFAILED;
6390       }
6391
6392       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6393       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6394       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6395       {
6396          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6397          return RFAILED;
6398       }
6399
6400       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6401       {
6402          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6403          return RFAILED;
6404       }
6405       idx++;
6406    }
6407
6408    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6409    {
6410       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6411          continue;
6412
6413       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6414
6415       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6416       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6417       {
6418          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6419          return RFAILED;
6420       }
6421
6422       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6423       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6424
6425       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6426       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6427       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6428       if(!rlcBearerList->list.array[idx]->rlc_Config)
6429       {
6430          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6431          return RFAILED;
6432       }
6433
6434       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6435       {
6436          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6437          return RFAILED;
6438       }
6439
6440       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6441       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6442       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6443       {
6444          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6445          return RFAILED;
6446       }
6447
6448       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6449       {
6450          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6451          return RFAILED;
6452       }
6453       idx++;
6454    }
6455    return ROK;
6456 }
6457
6458 /*******************************************************************
6459  *
6460  * @brief Free memory allocated for CellGroupConfig
6461  *
6462  * @details
6463  *
6464  *    Function : FreeMemCellGrpCfg
6465  *
6466  *    Functionality: Deallocating memory of CellGroupConfig
6467  *
6468  * @params[in] pointer to CellGroupConfigRrc_t
6469  *
6470  * @return ROK     - success
6471  *         RFAILED - failure
6472  *
6473  ******************************************************************/
6474 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6475 {
6476    uint8_t idx=0;
6477    SpCellConfig_t *spCellCfg=NULLP;
6478    ServingCellConfig_t *srvCellCfg=NULLP;
6479    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6480    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6481    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6482    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6483    struct RLC_Config *rlcConfig=NULLP;
6484    struct LogicalChannelConfig *macLcConfig=NULLP;
6485    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6486    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6487    struct TAG_Config *tagConfig=NULLP;
6488    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6489    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6490    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6491
6492    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6493    if(rlcBearerList)
6494    {
6495       if(rlcBearerList->list.array)
6496       {
6497          for(idx=0; idx<rlcBearerList->list.count; idx++)
6498          {
6499             if(rlcBearerList->list.array[idx])
6500             {
6501                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6502                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6503                if(rlcConfig)
6504                {
6505                   if(rlcConfig->choice.am)
6506                   {
6507                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6508                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6509                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6510                   }
6511                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6512                }
6513                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6514                if(macLcConfig)
6515                {
6516                   if(macLcConfig->ul_SpecificParameters)
6517                   {
6518                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6519                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6520                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6521                   }
6522                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6523                }
6524                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6525             }
6526          }
6527          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6528       }
6529       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6530    }
6531
6532    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6533    if(macCellGrpCfg)
6534    {
6535       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6536       if(schedulingRequestConfig)
6537       {
6538          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6539          if(schReqList)
6540          {
6541             if(schReqList->list.array)
6542             {
6543                for(idx=0;idx<schReqList->list.count; idx++)
6544                {
6545                   if(schReqList->list.array[idx])
6546                   {
6547                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6548                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6549                   }
6550                }
6551                CU_FREE(schReqList->list.array, schReqList->list.size);
6552             }
6553             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6554                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6555             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6556       }
6557       if(macCellGrpCfg->bsr_Config)
6558       {
6559          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6560       }
6561       tagConfig = macCellGrpCfg->tag_Config;
6562       if(tagConfig)
6563       {
6564          tagList = tagConfig->tag_ToAddModList;
6565          if(tagList)
6566          {
6567             if(tagList->list.array)
6568             {
6569                for(idx=0; idx<tagList->list.count; idx++)
6570                {
6571                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6572                }
6573                CU_FREE(tagList->list.array, tagList->list.size);
6574             }
6575             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6576          }
6577          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6578       }
6579
6580       phrConfig = macCellGrpCfg->phr_Config;
6581       if(phrConfig)
6582       {
6583          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6584          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6585       }
6586
6587       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6588    }
6589
6590    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6591    if(phyCellGrpCfg)
6592    {
6593       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6594       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6595    }
6596
6597    spCellCfg = cellGrpCfg->spCellConfig;
6598    if(spCellCfg)
6599    {
6600       if(spCellCfg->servCellIndex)
6601       {
6602          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6603          {
6604             if(spCellCfg->spCellConfigDedicated)
6605             {
6606                srvCellCfg = spCellCfg->spCellConfigDedicated;
6607                if(srvCellCfg->initialDownlinkBWP)
6608                {
6609                   dlBwp = srvCellCfg->initialDownlinkBWP;
6610                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6611                   {
6612                      if(srvCellCfg->defaultDownlinkBWP_Id)
6613                      {
6614                         if(srvCellCfg->uplinkConfig)
6615                         {
6616                            if(srvCellCfg->pdsch_ServingCellConfig)
6617                            {
6618                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6619                               if(pdschCfg->choice.setup)
6620                               {
6621                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6622                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6623                               }
6624                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6625                                        ServingCellConfig__pdsch_ServingCellConfig));
6626                            }
6627                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6628                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6629                         }
6630                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6631                      }
6632                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6633                   }
6634                   if(dlBwp->pdcch_Config)
6635                   {
6636                      if(dlBwp->pdsch_Config)
6637                      {
6638                         FreeBWPDlDedPdschCfg(dlBwp);
6639                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6640                      }
6641                      FreeBWPDlDedPdcchCfg(dlBwp);
6642                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6643                   }
6644                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6645                }
6646                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6647             }
6648             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6649          }
6650          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6651       }
6652       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6653    }
6654    return ROK;
6655 }
6656
6657 /*******************************************************************
6658  *
6659  * @brief Fills CellGroupConfig
6660  *
6661  * @details
6662  *
6663  *    Function : fillCellGrpCfg
6664  *
6665  *    Functionality: Fills CellGroupConfig
6666  *
6667  * @params[in] pointer to CellGroupConfigRrc_t
6668  *
6669  * @return ROK     - success
6670  *         RFAILED - failure
6671  *
6672  ******************************************************************/
6673
6674 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6675 {
6676    uint8_t               ret = RFAILED;
6677    CellGroupConfigRrc_t  cellGrpCfg;
6678    asn_enc_rval_t        encRetVal;
6679
6680    while(true)
6681    {
6682       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6683
6684       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6685
6686       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6687       {
6688          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6689          break;
6690       }
6691
6692       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6693       cellGrpCfg.mac_CellGroupConfig = NULLP;
6694       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6695       if(!cellGrpCfg.mac_CellGroupConfig)
6696       {
6697          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6698          break;
6699       }
6700       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6701       {
6702          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6703          break;
6704       }
6705
6706       cellGrpCfg.physicalCellGroupConfig = NULLP;
6707       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6708       if(!cellGrpCfg.physicalCellGroupConfig)
6709       {
6710          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6711          break;
6712       }
6713       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6714       {
6715          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6716          break;
6717       }
6718
6719       cellGrpCfg.spCellConfig = NULLP;
6720       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6721       if(!cellGrpCfg.spCellConfig)
6722       {
6723          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6724          break;
6725       }
6726       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6727       {
6728          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6729          break;
6730       }
6731
6732       cellGrpCfg.sCellToAddModList = NULLP;
6733       cellGrpCfg.sCellToReleaseList = NULLP;
6734       cellGrpCfg.ext1 = NULLP;
6735
6736       /* encode cellGrpCfg into duToCuRrcContainer */
6737       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6738       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6739       encBufSize = 0;
6740       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6741       /* Encode results */
6742       if(encRetVal.encoded == ENCODE_FAIL)
6743       {
6744          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6745                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6746          break;
6747       }
6748       else
6749       {
6750          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6751          for(int i=0; i< encBufSize; i++)
6752          {
6753             DU_LOG("%x",encBuf[i]);
6754          }
6755       }
6756
6757       cellGrp->size = encBufSize;
6758       CU_ALLOC(cellGrp->buf, cellGrp->size);
6759       if(!cellGrp->buf)
6760       {
6761          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6762          break;
6763       }
6764       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6765       ret = ROK;
6766       break;
6767    }
6768    FreeMemCellGrpCfg(&cellGrpCfg);
6769    return ret;
6770 }
6771
6772 /*******************************************************************
6773  *
6774  * @brief Free UE Capability RAT container
6775  *
6776  * @details
6777  *
6778  *    Function : freeUeCapRatCont
6779  *
6780  *    Functionality:
6781  *       Free UE Capability RAT conatiner
6782  *
6783  * @params[in]
6784  * @return ROK     - success
6785  *         RFAILED - failure
6786  *
6787  * ****************************************************************/
6788 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6789 {
6790    uint8_t idx;
6791    FeatureSets_t *featureSets;
6792
6793    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6794    {
6795       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6796       {
6797          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6798             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6799       }
6800       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6801    }
6802
6803    if(ueNrCap->featureSets)
6804    {
6805       featureSets = ueNrCap->featureSets;
6806       if(featureSets->featureSetsDownlinkPerCC)
6807       {
6808          if(featureSets->featureSetsDownlinkPerCC->list.array)
6809          {
6810             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6811             {
6812                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6813                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6814                         sizeof(ModulationOrder_t));
6815                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6816             }
6817             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6818          }
6819          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6820       }
6821
6822       if(featureSets->featureSetsUplinkPerCC)
6823       {
6824          if(featureSets->featureSetsUplinkPerCC->list.array)
6825          {
6826             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6827             {
6828                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6829                {
6830                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6831                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6832                          sizeof(ModulationOrder_t));
6833                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6834                }
6835             }
6836             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6837          }
6838          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6839       }
6840       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6841    }
6842 }
6843
6844 /*******************************************************************
6845  *
6846  * @brief Free UE capability RAT container list
6847  *
6848  * @details
6849  *
6850  *    Function : freeUeCapRatContList
6851  *
6852  *    Functionality: Free UE capability RAT container list
6853  *
6854  * @params[in]
6855  * @return ROK     - success
6856  *         RFAILED - failure
6857  *
6858  * ****************************************************************/
6859 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6860 {
6861    uint8_t idx;
6862    if(ueCapablityList->list.array)
6863    {
6864       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6865       {
6866          if(ueCapablityList->list.array[idx])
6867             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6868       }
6869       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6870    }
6871 }
6872
6873 /*******************************************************************
6874  *
6875  * @brief Free Handover preparation information
6876  *
6877  * @details
6878  *
6879  *    Function : freeHOPreparationInfo
6880  *
6881  *    Functionality: Free Handover preparation information
6882  *
6883  * @params[in]
6884  * @return ROK     - success
6885  *         RFAILED - failure
6886  *
6887  * ****************************************************************/
6888 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6889 {
6890    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6891
6892    if(hoPrep->criticalExtensions.choice.c1)
6893    {
6894       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6895       {
6896          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6897          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6898          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6899                sizeof(HandoverPreparationInformationRrc_IEs_t));
6900       }
6901       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6902    }
6903 }
6904
6905 /*******************************************************************
6906  *
6907  * @brief Fill feature sets
6908  *
6909  * @details
6910  *
6911  *    Function : fillFeatureSets
6912  *
6913  *    Functionality: Fill feature sets
6914  *
6915  * @params[in]
6916  * @return ROK     - success
6917  *         RFAILED - failure
6918  *
6919  * ****************************************************************/
6920 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6921 {
6922    uint8_t idx, elementCnt;
6923
6924    featureSets->featureSetsDownlink = NULLP;
6925    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6926    if(!featureSets->featureSetsDownlinkPerCC)
6927    {
6928       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6929       return RFAILED;
6930    }
6931
6932    elementCnt = 1;
6933    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6934    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6935    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6936    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6937    {
6938       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6939       return RFAILED;
6940    }
6941
6942    for(idx = 0; idx < elementCnt; idx++)
6943    {
6944       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6945       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6946       {
6947          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6948          return RFAILED;
6949       }
6950    }
6951
6952    idx = 0;
6953    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6954    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6955    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6956    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6957    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6958
6959    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6960    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6961    {
6962       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6963       return RFAILED;
6964    }
6965    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6966
6967    featureSets->featureSetsUplink = NULLP;
6968    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6969    if(!featureSets->featureSetsUplinkPerCC)
6970    {
6971       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6972       return RFAILED;
6973    }
6974
6975    elementCnt = 1;
6976    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6977    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6978    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6979    if(!featureSets->featureSetsUplinkPerCC->list.array)
6980    {
6981       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6982       return RFAILED;
6983    }
6984
6985    for(idx = 0; idx < elementCnt; idx++)
6986    {
6987       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6988       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6989       {
6990          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6991          return RFAILED;
6992       }
6993    }
6994
6995    idx = 0;
6996    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6997    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6998    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6999    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
7000    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
7001    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
7002
7003    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
7004    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
7005    {
7006       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7007       return RFAILED;
7008    }
7009    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
7010
7011    return ROK;
7012 }
7013
7014 /*******************************************************************
7015  *
7016  * @brief Fill UE capability RAT container
7017  *
7018  * @details
7019  *
7020  *    Function : fillUeCapRatCont
7021  *
7022  *    Functionality: Fill UE capability RAT container
7023  *
7024  * @params[in] UE Capability RAT container buffer
7025  * @return ROK     - success
7026  *         RFAILED - failure
7027  *
7028  * ****************************************************************/
7029 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
7030 {
7031    uint8_t             ret = ROK;
7032    uint8_t             idx, elementCnt;
7033    asn_enc_rval_t      encRetVal;
7034    UE_NR_Capability_t  ueNrCap;
7035
7036    while(true)
7037    {
7038       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
7039
7040       /* Filling PDCP parameters */
7041       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
7042       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
7043       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
7044       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
7045       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
7046       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
7047       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
7048       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
7049       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
7050       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
7051       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
7052       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
7053       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
7054       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
7055       ueNrCap.pdcp_Parameters.shortSN = NULLP;
7056       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
7057       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
7058
7059       ueNrCap.rlc_Parameters = NULLP;
7060       ueNrCap.mac_Parameters = NULLP;
7061
7062       /* Filling PHY parameters */
7063       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
7064       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
7065       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
7066       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
7067       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
7068
7069       /* Filling RF parameters */
7070       elementCnt = 1;
7071       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
7072       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
7073       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
7074       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
7075       {
7076          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
7077          ret = RFAILED;
7078          break;
7079       }
7080
7081       for(idx = 0; idx < elementCnt; idx++)
7082       {
7083          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
7084          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
7085          {
7086             ret = RFAILED;
7087             break;
7088          }
7089       }
7090       if(ret == RFAILED)
7091          break;
7092
7093       idx = 0;
7094       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
7095       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
7096       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
7097
7098       ueNrCap.measAndMobParameters = NULLP;
7099       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
7100       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
7101       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
7102       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
7103       ueNrCap.featureSets = NULLP;
7104
7105       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
7106       if(!ueNrCap.featureSets)
7107       {
7108          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
7109          ret = RFAILED;
7110          break;
7111       }
7112
7113       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
7114       {
7115          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
7116          ret = RFAILED;
7117          break;
7118       }
7119
7120       ueNrCap.featureSetCombinations = NULLP;
7121       ueNrCap.lateNonCriticalExtension = NULLP;
7122       ueNrCap.nonCriticalExtension = NULLP;
7123
7124       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7125       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
7126       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7127       encBufSize = 0;
7128       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
7129
7130       /* Encode results */
7131       if(encRetVal.encoded == ENCODE_FAIL)
7132       {
7133          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7134             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7135          break;
7136       }
7137       else
7138       {
7139          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7140          for(int i=0; i< encBufSize; i++)
7141          {
7142             DU_LOG("%x",encBuf[i]);
7143          }
7144       }
7145
7146       ueCapRatContBuf->size = encBufSize;
7147       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
7148       if(!ueCapRatContBuf->buf)
7149       {
7150          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7151          break;
7152       }
7153       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
7154       ret = ROK;
7155       break;
7156    }
7157    freeUeCapRatCont(&ueNrCap);
7158    return ROK;
7159 }
7160
7161 /*******************************************************************
7162  *
7163  * @brief Fill UE Capability RAT container list
7164  *
7165  * @details
7166  *
7167  *    Function : fillUeCapRatContList
7168  *
7169  *    Functionality: Fill UE Capability RAT container list
7170
7171  *
7172  * @params[in] UE capability RAT container list
7173  * @return ROK     - success
7174  *         RFAILED - failure
7175  *
7176  * ****************************************************************/
7177 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
7178 {
7179     uint8_t          ret = RFAILED;
7180     uint8_t          idx, elementCnt;
7181
7182     while(true)
7183     {
7184        elementCnt = 1;
7185        ueCapablityList->list.count = elementCnt;
7186        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
7187
7188        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
7189        if(!ueCapablityList->list.array)
7190        {
7191           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7192           ret = RFAILED;
7193           break;
7194        }
7195
7196        for(idx=0; idx<elementCnt; idx++)
7197        {
7198           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
7199           if(ueCapablityList->list.array[idx] == NULLP)
7200           {
7201              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7202              ret = RFAILED;
7203              break;
7204           }
7205        }
7206        idx = 0;
7207        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
7208        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
7209        {
7210           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
7211           ret = RFAILED;
7212           break;
7213        }
7214
7215        ret = ROK;
7216        break;
7217     }
7218     return ret;
7219 }
7220
7221 /*******************************************************************
7222  *
7223  * @brief Fill UE Capability RAT container list octet string
7224  *
7225  * @details
7226  *
7227  *    Function : fillUeCapRatContListBuf
7228  *
7229  *    Functionality: Fill UE Capability RAT container list octet string
7230
7231  *
7232  * @params[in] UE capability RAT container list buffer
7233  * @return ROK     - success
7234  *         RFAILED - failure
7235  *
7236  * ****************************************************************/
7237 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
7238 {
7239    uint8_t          ret = RFAILED;
7240    asn_enc_rval_t   encRetVal;
7241    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7242
7243    while(true)
7244    {
7245       ret = fillUeCapRatContList(&ueCapablityList);
7246       if(ret != ROK)
7247       {
7248          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7249          break;
7250       }
7251
7252       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7253       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7254       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7255       encBufSize = 0;
7256       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7257             &ueCapablityList, PrepFinalEncBuf, encBuf);
7258
7259       /* Encode results */
7260       if(encRetVal.encoded == ENCODE_FAIL)
7261       {
7262          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7263                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7264          break;
7265       }
7266       else
7267       {
7268          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7269          for(int i=0; i< encBufSize; i++)
7270          {
7271             DU_LOG("%x",encBuf[i]);
7272          }
7273       }
7274
7275       ueCapablityListBuf->size = encBufSize;
7276       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7277       if(!ueCapablityListBuf->buf)
7278       {
7279          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7280          break;
7281       }
7282       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7283       ret = ROK;
7284       break;
7285    }
7286    freeUeCapRatContList(&ueCapablityList);
7287    return ret;
7288 }
7289
7290 /*******************************************************************
7291  *
7292  * @brief Free Measurement Timing Configuration
7293  *
7294  * @details
7295  *
7296  *    Function : freeMeasuementTimingConfig
7297  *
7298  *    Functionality: Free Measurement Timing Configuration
7299  *
7300  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7301  * @return void
7302  *
7303  * ****************************************************************/
7304 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7305 {
7306    uint8_t measCfgIdx;
7307    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7308    MeasTiming_t *measTiming = NULLP;
7309
7310    if(measTimingConfig.criticalExtensions.choice.c1)
7311    {
7312       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7313       {
7314          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7315          if(measTimingCfg->measTiming)
7316          {
7317             if(measTimingCfg->measTiming->list.array)
7318             {
7319                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7320                {
7321                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7322                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7323                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7324                }
7325                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7326             }
7327             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7328          }
7329          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7330       }
7331       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7332    }
7333 }
7334
7335 /*******************************************************************
7336  *
7337  * @brief Fill Measurement Timing Configuration
7338  *
7339  * @details
7340  *
7341  *    Function : fillMeasTimingCfg
7342  *
7343  *    Functionality: Fill Measurement Timing Configuration
7344  *
7345  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7346  * @return ROK     - success
7347  *         RFAILED - failure
7348  *
7349  * ****************************************************************/
7350 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7351 {
7352    uint8_t elementCnt = 0;
7353    uint8_t measCfgIdx = 0;
7354    MeasTiming_t *measTiming;
7355    SSB_MTC_t *smtc;
7356
7357    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7358    if(!measTimingCfg->measTiming)
7359    {
7360       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7361       return RFAILED;
7362    }
7363
7364    elementCnt = 1;
7365    measTimingCfg->measTiming->list.count = elementCnt;
7366    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7367    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7368    if(!measTimingCfg->measTiming->list.array)
7369    {
7370       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7371       return RFAILED;
7372    }
7373
7374    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7375    {
7376       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7377       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7378       {
7379          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7380          return RFAILED;
7381       }
7382    }
7383
7384    measCfgIdx = 0;
7385    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7386    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7387    if(!measTiming->frequencyAndTiming)
7388    {
7389       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7390       return RFAILED;
7391    }
7392
7393    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7394    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7395
7396    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7397    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7398    smtc->periodicityAndOffset.choice.sf20 = 0;
7399    smtc->duration = SSB_MTC__duration_sf1;
7400    return ROK;
7401 }
7402
7403 /*******************************************************************
7404  *
7405  * @brief Fill Measurement Timing Configuration Octet string
7406  *
7407  * @details
7408  *
7409  *    Function : fillMeasConfigBuf
7410  *
7411  *    Functionality: Fill Measurement Timing Configuration Octet string
7412
7413  *
7414  * @params[in] MeasConfig_t *measConfgBuf
7415  * @return ROK     - success
7416  *         RFAILED - failure
7417  *
7418  * ****************************************************************/
7419 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7420 {
7421    uint8_t          ret = RFAILED;
7422    asn_enc_rval_t   encRetVal;
7423    MeasurementTimingConfigurationRrc_t measTimingConfig;
7424
7425    while(true)
7426    {
7427       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7428       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7429       if(!measTimingConfig.criticalExtensions.choice.c1)
7430       {
7431          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7432          return RFAILED;
7433       }
7434       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7435
7436       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7437       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7438       {
7439          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7440          return RFAILED;
7441       }
7442
7443       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7444       if(ret != ROK)
7445       {
7446          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7447          break;
7448       }
7449
7450       /* Encode measurement timing configuration into octet string */
7451       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7452       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7453       encBufSize = 0;
7454       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7455
7456       /* Encode results */
7457       if(encRetVal.encoded == ENCODE_FAIL)
7458       {
7459          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7460                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7461          break;
7462       }
7463       else
7464       {
7465          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7466          for(int i=0; i< encBufSize; i++)
7467          {
7468             DU_LOG("%x",encBuf[i]);
7469          }
7470       }
7471
7472       measTimingConfigBuf->size = encBufSize;
7473       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7474       if(!measTimingConfigBuf->buf)
7475       {
7476          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7477          break;
7478       }
7479       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7480       ret = ROK;
7481       break;
7482    }
7483    freeMeasuementTimingConfig(measTimingConfig);
7484    return ret;
7485 }
7486
7487 /******************************************************************
7488  *
7489  * @brief Free RRC reconfiguration non-critical extension
7490  *
7491  * @details
7492  *
7493  *    Function : freeRrcReconfigNonCriticalExt
7494  *
7495  *    Functionality: Free RRC reconfiguration non-critical extension
7496  *
7497  * @params[in] RRC reconfiguration IE
7498  * @return void
7499  *
7500  * ****************************************************************/
7501 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7502 {
7503    if(rrcRecfg->masterCellGroup)
7504    {
7505       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7506    }
7507 }
7508
7509 /******************************************************************
7510  *
7511  * @brief Free measurement object addmod list
7512  *
7513  * @details
7514  *
7515  *    Function : freeMeasObjToAddModList
7516  *
7517  *    Functionality: Free measurement object add mod list
7518  *
7519  * @params[in] Measurement object add/mod list
7520  * @return void
7521  *
7522  * ****************************************************************/
7523 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7524 {
7525    uint8_t objIdx;
7526    MeasObjectNR_t *measObject;
7527
7528    if(measObjList->list.array)
7529    {
7530       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7531       {
7532          if(measObjList->list.array[objIdx])
7533          {
7534             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7535             {
7536                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7537                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7538                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7539                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7540                if(measObject->absThreshSS_BlocksConsolidation)
7541                {
7542                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7543                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7544                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7545                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7546                }
7547                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7548                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7549                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7550                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7551                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7552             }
7553             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7554          }
7555       }
7556       CU_FREE(measObjList->list.array, measObjList->list.size);
7557    }
7558 }
7559
7560 /******************************************************************
7561  *
7562  * @brief Free report config add mod list
7563  *
7564  * @details
7565  *
7566  *    Function : freeReportCfgToAddModList
7567  *
7568  *    Functionality: Free report config add mod list
7569  *
7570  * @params[in] Report config list
7571  * @return void
7572  *
7573  * ****************************************************************/
7574 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7575 {
7576    uint8_t reportCfgIdx;
7577    ReportConfigToAddMod_t *reportCfg;
7578    ReportConfigNR_t *reportCfgNr;
7579    EventTriggerConfig_t *eventTriggCfg;
7580
7581    if(reportCfgList->list.array)
7582    {
7583       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7584       {
7585          if(reportCfgList->list.array[reportCfgIdx])
7586          {
7587             reportCfg = reportCfgList->list.array[reportCfgIdx];
7588             if(reportCfg->reportConfig.choice.reportConfigNR)
7589             {
7590                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7591                if(reportCfgNr->reportType.choice.eventTriggered)
7592                {
7593                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7594                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7595                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7596                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7597                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7598                }
7599             }
7600          }
7601          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7602       }
7603       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7604    }
7605 }
7606
7607 /******************************************************************
7608  *
7609  * @brief Free measurement id to add mod list
7610  *
7611  * @details
7612  *
7613  *    Function : freeMeasIdToAddModList
7614  *
7615  *    Functionality: Free measurement id to add mod list
7616  *
7617  * @params[in] Measurement id to add mod list
7618  * @return void
7619  *
7620  * ****************************************************************/
7621 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7622 {
7623    uint8_t measIdIdx;
7624    if(measIdList->list.array)
7625    {
7626       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7627       {
7628          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7629       }
7630       CU_FREE(measIdList->list.array, measIdList->list.size);
7631    }
7632 }
7633
7634 /*******************************************************************
7635  *
7636  * @brief Free quantity config
7637  *
7638  * @details
7639  *
7640  *    Function : freeQunatityConfig
7641  *
7642  *    Functionality: Free quantity config
7643  *
7644  * @params[in] Quantity Config
7645  * @return void
7646  *
7647  * ****************************************************************/
7648 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7649 {
7650    uint8_t quanCfgIdx;
7651    QuantityConfigNR_t *quantityCfgNr;
7652
7653    if(quantityCfg->quantityConfigNR_List)
7654    {
7655       if(quantityCfg->quantityConfigNR_List->list.array)
7656       {
7657          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7658          {
7659             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7660             {
7661                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7662                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7663                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7664                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7665                if(quantityCfgNr->quantityConfigRS_Index)
7666                {
7667                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7668                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7669                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7670                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7671                }
7672                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7673             }
7674          }
7675          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7676       }
7677       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7678    }
7679 }
7680
7681 /******************************************************************
7682  *
7683  * @brief Free measurement Config
7684  *
7685  * @details
7686  *
7687  *    Function : freeMeasConfig
7688  *
7689  *    Functionality: Free measurement config
7690  *
7691  * @params[in] Measurement config
7692  * @return void
7693  *
7694  * ****************************************************************/
7695 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7696 {
7697    if(measConfig->measObjectToAddModList)
7698    {
7699       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7700       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7701    }
7702    if(measConfig->reportConfigToAddModList)
7703    {
7704       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7705       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7706    }
7707    if(measConfig->measIdToAddModList)
7708    {
7709       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7710       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7711    }
7712    if(measConfig->s_MeasureConfig)
7713    {
7714       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7715    }
7716    if(measConfig->quantityConfig)
7717    {
7718       freeQuantityConfig(measConfig->quantityConfig);
7719       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7720    }
7721 }
7722 /******************************************************************
7723  *
7724  * @brief Free DRB to AddMod List
7725  *
7726  * @details
7727  *
7728  *    Function : freeDrbToAddModList
7729  *
7730  *    Functionality: Free SRB to AddMod List
7731  *
7732  * @params[in] SBR to add/mod list
7733  * @return void
7734  *
7735  * ****************************************************************/
7736 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7737 {
7738    uint8_t drbIdx;
7739    if(drbToAddList->list.array)
7740    {
7741       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7742       {
7743          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7744          {
7745             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7746             {
7747                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7748                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7749                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7750                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7751             }
7752             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7753             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7754          }
7755          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7756       }
7757       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7758    }
7759 }
7760
7761 /******************************************************************
7762  *
7763  * @brief Free SRB to AddMod List
7764  *
7765  * @details
7766  *
7767  *    Function : freeSrbToAddModList
7768  *
7769  *    Functionality: Free SRB to AddMod List
7770  *
7771  * @params[in] SBR to add/mod list
7772  * @return void
7773  *
7774  * ****************************************************************/
7775 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7776 {
7777    uint8_t srbIdx;
7778    if(srbToAddList->list.array)
7779    {
7780       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7781       {
7782          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7783          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7784          {
7785             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7786             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7787          }
7788
7789          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7790       }
7791       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7792    }
7793 }
7794
7795 /******************************************************************
7796  *
7797  * @brief Free Radio Bearer Config
7798  *
7799  * @details
7800  *
7801  *    Function : freeRadioBearerConfig
7802  *
7803  *    Functionality: Free Radio Bearer config
7804  *
7805  * @params[in] Radio bearer config
7806  * @return void
7807  *
7808  * ****************************************************************/
7809 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7810 {
7811    if(radioBearerConfig->srb_ToAddModList)
7812    {
7813       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7814       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7815    }
7816    if(radioBearerConfig->drb_ToAddModList)
7817    {
7818       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7819       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7820    }
7821 }
7822
7823 /******************************************************************
7824  *
7825  * @brief Free reconfiguration message
7826  *
7827  * @details
7828  *
7829  *    Function : freeRrcReconfig
7830  *
7831  *    Functionality: Free reconfiguration message
7832  *
7833  * @params[in] RRC Reconfiguration message
7834  * @return void
7835  *
7836  * ****************************************************************/
7837 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7838 {
7839    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7840    {
7841       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7842       {
7843          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7844          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7845       }
7846       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7847       {
7848          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7849          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7850       }
7851       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7852       {
7853          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7854          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7855       }
7856       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7857    }
7858 }
7859
7860 /******************************************************************
7861  *
7862  * @brief Fill SRB To Add Mod list
7863  *
7864  * @details
7865  *
7866  *    Function : fillSrbToAddModList
7867  *
7868  *    Functionality: fill SRB to Add Mod list
7869  *
7870  * @params[in] UE control block
7871  *             SRB to Add/Mod list
7872  * @return ROK     - success
7873  *         RFAILED - failure
7874  *
7875  * ****************************************************************/
7876 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7877 {
7878    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7879
7880    if(updateAllRbCfg)
7881       elementCnt = ueCb->numSrb;
7882    else
7883    {
7884       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7885       {
7886          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7887             elementCnt++;
7888       }
7889    }
7890
7891    if(!elementCnt)
7892    {
7893       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7894       return ROK;
7895    }
7896
7897    srbToAddList->list.count = elementCnt;
7898    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7899
7900    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7901    if(!srbToAddList->list.array)
7902    {
7903       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7904       return RFAILED;
7905    }
7906
7907    srbIdx = 0;
7908    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7909    {
7910       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7911          continue;
7912
7913       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7914       if(!srbToAddList->list.array[srbIdx])
7915       {
7916          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7917          return RFAILED;
7918       }
7919
7920       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7921
7922       /* Reestablish PDCP */
7923       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7924       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7925       {
7926          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7927          return RFAILED;
7928       }
7929       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7930
7931       /* PDCP configuration */
7932       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7933       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7934       {
7935          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7936          return RFAILED;
7937       }
7938
7939       /* Reordering timer */
7940       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7941       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7942       {
7943          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7944          return RFAILED;
7945       }
7946       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7947
7948       srbIdx++;
7949    }
7950    return ROK;
7951 }
7952
7953 /******************************************************************
7954  *
7955  * @biief Fill DRBeTo Add Mod list
7956  *
7957  * @details
7958  *
7959  *    Function : fillDrbToAddModList
7960  *
7961  *    Functionality: fill DRB to Add Mod list
7962  *
7963  * @params[in] UE control block
7964  *             DRB to Add/Mod list
7965  * @return ROK     - success
7966  *         RFAILED - failure
7967  *
7968  * ****************************************************************/
7969 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7970 {
7971    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7972
7973    if(updateAllRbCfg)
7974       elementCnt = ueCb->numDrb;
7975    else
7976    {
7977       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7978       {
7979          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7980             elementCnt++;
7981       }
7982    }
7983
7984    if(!elementCnt)
7985    {
7986       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7987       return ROK;
7988    }
7989
7990
7991    drbToAddList->list.count = elementCnt;
7992    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7993
7994    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7995    if(!drbToAddList->list.array)
7996    {
7997       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7998       return RFAILED;
7999    }
8000
8001    drbIdx = 0;
8002    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
8003    {
8004       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
8005          continue;
8006
8007       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
8008       if(!drbToAddList->list.array[drbIdx])
8009       {
8010          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
8011          return RFAILED;
8012       }
8013
8014       /* DRB Id */
8015       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
8016
8017       /* PDCP Config */
8018       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
8019       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
8020       {
8021          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
8022          return RFAILED;
8023       }
8024
8025       /* PDCP Config -> DRB */
8026       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
8027       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
8028       {
8029          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
8030          return RFAILED;
8031       }
8032
8033       /* DRB -> Discard Timer */
8034       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
8035       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
8036       {
8037          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
8038          return RFAILED;
8039       }
8040       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
8041
8042       /* UL PDCP SN length */
8043       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
8044       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
8045       {
8046          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
8047          return RFAILED;
8048       }
8049       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
8050
8051       /* DL PDCP SN length */
8052       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
8053       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
8054       {
8055          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
8056          return RFAILED;
8057       }
8058       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
8059
8060       /* Header Compression */
8061       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
8062        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
8063
8064       /* Reordering timer */
8065       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
8066       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
8067       {
8068          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
8069          return RFAILED;
8070       }
8071       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
8072
8073       drbIdx++;
8074    }
8075
8076    return ROK;
8077 }
8078
8079 /******************************************************************
8080  *
8081  * @brief Fill Radio bearer configuration
8082  *
8083  * @details
8084  *
8085  *    Function : fillRadioBearerConfig
8086  *
8087  *    Functionality: Fill Radio bearer configuration
8088  *
8089  * @params[in] UE control block
8090  *             Radio bearer config pointer
8091  * @return ROK     - success
8092  *         RFAILED - failure
8093  *
8094  * ****************************************************************/
8095 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
8096 {
8097    /* SRB To Add/Mod List */
8098    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
8099    if(!radioBearerConfig->srb_ToAddModList)
8100    {
8101       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
8102       return RFAILED;
8103    }
8104    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
8105    {
8106       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
8107       return RFAILED;
8108    }
8109
8110    /* DRB To Add/Mod List */
8111    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
8112    if(!radioBearerConfig->drb_ToAddModList)
8113    {
8114       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
8115       return RFAILED;
8116     }
8117    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
8118    {
8119       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
8120       return RFAILED;
8121    }
8122
8123    return ROK;
8124 }
8125
8126 /*******************************************************************
8127  *
8128  * @brief Fill measurement object to add/mod list
8129  *
8130  * @details
8131  *
8132  *    Function : fillMeasObjToAddModList
8133  *
8134  *    Functionality: Fill measurement object to add/mod list
8135  *
8136  * @params[in] Measurement object to add/mod list
8137  * @return ROK     - success
8138  *         RFAILED - failure
8139  *
8140  * ****************************************************************/
8141 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
8142 {
8143    uint8_t elementCnt, objIdx;
8144    MeasObjectNR_t *measObject;
8145
8146    elementCnt = 1;
8147    measObjList->list.count = elementCnt;
8148    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
8149
8150    CU_ALLOC(measObjList->list.array, measObjList->list.size);
8151    if(!measObjList->list.array)
8152    {
8153       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
8154       return RFAILED;
8155    }
8156
8157    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
8158    {
8159       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
8160       if(!measObjList->list.array[objIdx])
8161       {
8162          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
8163          return RFAILED;
8164       }
8165    }
8166
8167    objIdx = 0;
8168    measObjList->list.array[objIdx]->measObjectId = 1;
8169    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
8170    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
8171    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
8172    {
8173       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
8174       return RFAILED;
8175    }
8176
8177    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
8178
8179    /* SSB frequency */
8180    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
8181    if(!measObject->ssbFrequency)
8182    {
8183       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
8184       return RFAILED;
8185    }
8186    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
8187
8188    /* Subcarrier spacing */
8189    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8190    if(!measObject->ssbSubcarrierSpacing)
8191    {
8192       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
8193       return RFAILED;
8194    }
8195    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
8196
8197    /* SMTC1 */
8198    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
8199    if(!measObject->smtc1)
8200    {
8201       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
8202       return RFAILED;
8203    }
8204    measObject->smtc1->duration = SSB_MTC__duration_sf1;
8205    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
8206    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
8207
8208    /* Absoulute threshold SSB consolidation */
8209    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
8210    if(!measObject->absThreshSS_BlocksConsolidation)
8211    {
8212       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
8213       return RFAILED;
8214    }
8215
8216    /* RSRP threshold */
8217    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
8218    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
8219    {
8220       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
8221       return RFAILED;
8222    }
8223    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
8224
8225    /* RSRQ threshold */
8226    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
8227    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
8228    {
8229       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
8230       return RFAILED;
8231    }
8232    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
8233
8234    /* SINR threshold */
8235    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
8236    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
8237    {
8238       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
8239       return RFAILED;
8240    }
8241    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8242
8243    /* Number of SSBs to average */
8244    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8245    if(!measObject->nrofSS_BlocksToAverage)
8246    {
8247       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8248       return RFAILED;
8249    }
8250    *(measObject->nrofSS_BlocksToAverage) = 2;
8251
8252    /* Quantity Config index */
8253    measObject->quantityConfigIndex = 1;
8254
8255    /* Offset MO */
8256    /* RSRP offset for SSB */
8257    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8258    if(!measObject->offsetMO.rsrpOffsetSSB)
8259    {
8260       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8261       return RFAILED;
8262    }
8263    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8264
8265    /* RSRQ offset for SSB */
8266    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8267    if(!measObject->offsetMO.rsrpOffsetSSB)
8268    {
8269       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8270       return RFAILED;
8271    }
8272    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8273
8274    /* SINR offset for SSB */
8275    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8276    if(!measObject->offsetMO.sinrOffsetSSB)
8277    {
8278       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8279       return RFAILED;
8280    }
8281    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8282
8283    return ROK;
8284 }
8285
8286 /*******************************************************************
8287  *
8288  * @brief Fill Report configuration to Add/mod list
8289  *
8290  * @details
8291  *
8292  *    Function : fillReportCfgToAddModList
8293  *
8294  *    Functionality: Fill Report configuration to Add/mod list
8295  *
8296  * @params[in] Report Config To Add/Mod List
8297  * @return ROK     - success
8298  *         RFAILED - failure
8299  *
8300  * ****************************************************************/
8301 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8302 {
8303    uint8_t elementCnt;
8304    uint8_t reportCfgIdx;
8305    ReportConfigToAddMod_t *reportCfg;
8306    ReportConfigNR_t *reportCfgNr;
8307    EventTriggerConfig_t *eventTriggCfg;
8308
8309    elementCnt = 1;
8310    reportCfgList->list.count = elementCnt;
8311    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8312
8313    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8314    if(!reportCfgList->list.array)
8315    {
8316       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8317       return RFAILED;
8318    }
8319
8320    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8321    {
8322       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8323       if(!reportCfgList->list.array[reportCfgIdx])
8324       {
8325          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8326          return RFAILED;
8327       }
8328    }
8329
8330    reportCfgIdx = 0;
8331    reportCfg = reportCfgList->list.array[reportCfgIdx];
8332    reportCfg->reportConfigId = 1;
8333    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8334
8335    /* Report Configuration for NR */
8336    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8337    if(!reportCfg->reportConfig.choice.reportConfigNR)
8338    {
8339       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8340       return RFAILED;
8341    }
8342    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8343
8344    /* Report Type */
8345    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8346    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8347    if(!reportCfgNr->reportType.choice.eventTriggered)
8348    {
8349       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8350       return RFAILED;
8351    }
8352    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8353
8354    /* Event 3 */
8355    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8356    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8357    if(!eventTriggCfg->eventId.choice.eventA3)
8358    {
8359       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8360       return RFAILED;
8361    }
8362
8363    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8364    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8365    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8366    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8367    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8368    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8369
8370    /* Reference Signal Type */
8371    eventTriggCfg->rsType = NR_RS_Type_ssb;
8372
8373    /* Report Interval */
8374    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8375
8376    /* Report Amount */
8377    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8378
8379    /* Report Quantity cell */
8380    eventTriggCfg->reportQuantityCell.rsrp = true;
8381    eventTriggCfg->reportQuantityCell.rsrq = false;
8382    eventTriggCfg->reportQuantityCell.sinr = false;
8383
8384    /* Maximum reported cells */
8385    eventTriggCfg->maxReportCells = 3;
8386
8387    /* Report qunatity RS Indexes */
8388    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8389    if(!eventTriggCfg->reportQuantityRS_Indexes)
8390    {
8391       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8392       return RFAILED;
8393    }
8394    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8395    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8396    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8397
8398    /* Maximum number of RS indexes to report */
8399    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8400    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8401    {
8402       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8403       return RFAILED;
8404    }
8405    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8406
8407    /* Include Beam measurement */
8408    eventTriggCfg->includeBeamMeasurements = false;
8409
8410    return ROK;
8411 }
8412
8413 /*******************************************************************
8414  *
8415  * @brief Fill measurement Id to add/mod list
8416
8417  * @details
8418  *
8419  *    Function : fillMeasIdToAddModList
8420  *
8421  *    Functionality: Fill measurement Id to add/mod list
8422  *
8423  * @params[in] Measurement Id to add/mod list
8424  * @return ROK     - success
8425  *         RFAILED - failure
8426  *
8427  * ****************************************************************/
8428 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8429 {
8430    uint8_t elementCnt;
8431    uint8_t measIdIdx;
8432
8433    elementCnt = 1;
8434    measIdList->list.count = elementCnt;
8435    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8436
8437    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8438    if(!measIdList->list.array)
8439    {
8440       return RFAILED;
8441    }
8442
8443    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8444    {
8445       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8446       if(!measIdList->list.array[measIdIdx])
8447       {
8448          return RFAILED;
8449       }
8450
8451       measIdIdx=0;
8452       measIdList->list.array[measIdIdx]->measId = 1;
8453       measIdList->list.array[measIdIdx]->measObjectId = 1;
8454       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8455    }
8456    return ROK;
8457 }
8458
8459 /*******************************************************************
8460  *
8461  * @brief Fill s-measurement configuration
8462  *
8463  * @details
8464  *
8465  *    Function : fillSMeasConfig
8466  *
8467  *    Functionality: Fill s-measurement configuration
8468  *
8469  * @params[in] s-Measurement config
8470  * @return ROK     - success
8471  *         RFAILED - failure
8472  *
8473  * ****************************************************************/
8474 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8475 {
8476    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8477    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8478
8479    return ROK;
8480 }
8481
8482 /*******************************************************************
8483  *
8484  * @brief Fill quantity config
8485  *
8486  * @details
8487  *
8488  *    Function : fillQunatityConfig
8489  *
8490  *    Functionality: Fill quantity config
8491  *
8492  * @params[in] Quantity Config
8493  * @return ROK     - success
8494  *         RFAILED - failure
8495  *
8496  * ****************************************************************/
8497 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8498 {
8499    uint8_t elementCnt = 0;
8500    uint8_t quanCfgIdx = 0;
8501    QuantityConfigNR_t *quantityCfgNr;
8502
8503    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8504    if(!quantityCfg->quantityConfigNR_List)
8505    {
8506       return RFAILED;
8507    }
8508
8509    elementCnt = 1;
8510    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8511    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8512
8513    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8514    if(!quantityCfg->quantityConfigNR_List->list.array)
8515    {
8516       return RFAILED;
8517    }
8518
8519    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8520    {
8521       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8522       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8523       {
8524          return RFAILED;
8525       }
8526    }
8527
8528    quanCfgIdx = 0;
8529    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8530
8531    /* Quantity Config of Reference signal */
8532    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8533    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8534    {
8535       return RFAILED;
8536    }
8537    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8538
8539    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8540    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8541    {
8542       return RFAILED;
8543    }
8544    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8545
8546    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8547    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8548    {
8549       return RFAILED;
8550    }
8551    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8552
8553    /* Quantity Config RS index */
8554    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8555    if(!quantityCfgNr->quantityConfigRS_Index)
8556    {
8557       return RFAILED;
8558    }
8559
8560    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8561    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8562    {
8563       return RFAILED;
8564    }
8565    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8566
8567    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8568    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8569    {
8570       return RFAILED;
8571    }
8572    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8573
8574    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8575    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8576    {
8577       return RFAILED;
8578    }
8579    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8580
8581    return ROK;
8582 }
8583
8584 /*******************************************************************
8585  *
8586  * @brief Fill measurement configuration
8587  *
8588  * @details
8589  *
8590  *    Function : fillMeasConfig
8591  *
8592  *    Functionality: Fill measurement configuration
8593  *
8594  * @params[in] Measurement config
8595  * @return ROK     - success
8596  *         RFAILED - failure
8597  *
8598  * ****************************************************************/
8599 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8600 {
8601    /* Measurement object to add/mod list */
8602    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8603    if(!measConfig->measObjectToAddModList)
8604    {
8605       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8606       return RFAILED;
8607    }
8608    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8609    {
8610       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8611       return RFAILED;
8612    }
8613
8614    /* Report Config To add/mod list */
8615    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8616    if(!measConfig->reportConfigToAddModList)
8617    {
8618       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8619       return RFAILED;
8620    }
8621    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8622    {
8623       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8624       return RFAILED;
8625    }
8626
8627    /* Measurement Id to add/mod list */
8628    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8629    if(!measConfig->measIdToAddModList)
8630    {
8631       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8632       return RFAILED;
8633    }
8634    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8635    {
8636       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8637       return RFAILED;
8638    }
8639
8640    /* S-Measurement config */
8641    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8642    if(!measConfig->s_MeasureConfig)
8643    {
8644       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8645       return RFAILED;
8646    }
8647    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8648    {
8649       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8650       return RFAILED;
8651    }
8652
8653    /* Qunatity Config */
8654    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8655    if(!measConfig->quantityConfig)
8656    {
8657       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8658       return RFAILED;
8659    }
8660    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8661    {
8662       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8663       return RFAILED;
8664    }
8665
8666 return ROK;
8667 }
8668
8669 /*******************************************************************
8670  *
8671  * @brief Fill RRC reconfiguration non-critical extension IE
8672  *
8673  * @details
8674  *
8675  *    Function : fillRrcReconfigNonCriticalExt
8676  *
8677  *    Functionality: Fill RRC reconfiguration non-critical extension
8678  *
8679  * @params[in] RRC Reconfig Non-critical extension
8680  * @return ROK     - success
8681  *         RFAILED - failure
8682  *
8683  * ****************************************************************/
8684 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8685 {
8686    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8687    if(!rrcRecfg->masterCellGroup)
8688    {
8689       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8690       return RFAILED;
8691    }
8692
8693    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8694    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8695    if(!rrcRecfg->masterCellGroup->buf)
8696    {
8697       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8698       return RFAILED;
8699    }
8700    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8701
8702 #if 0
8703    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8704     * received from DU */
8705    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8706    {
8707       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8708       return RFAILED;
8709    }
8710 #endif
8711
8712    return ROK;
8713 }
8714
8715 /*******************************************************************
8716  *
8717  * @brief Fill RRC reconfiguration structure
8718  *
8719  * @details
8720  *
8721  *    Function : fillRrcReconfig
8722  *
8723  *    Functionality: Fill RRC reconfiguration
8724
8725  *
8726  * @params[in] UE Cb
8727  *             RRC reconfiguration structure
8728  * @return ROK     - success
8729  *         RFAILED - failure
8730  *
8731  * ****************************************************************/
8732 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8733 {
8734    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8735
8736    rrcReconfig->rrc_TransactionIdentifier = 1;
8737    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8738
8739    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8740    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8741    {
8742       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8743       return RFAILED;
8744    }
8745
8746    /* Radio Bearer Configuration */
8747    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8748    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8749    {
8750       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8751       return RFAILED;
8752    }
8753    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8754    {
8755       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8756       return RFAILED;
8757    }
8758
8759    /* Measurement Configuration */
8760    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8761    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8762    {
8763       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8764       return RFAILED;
8765    }
8766    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8767    {
8768       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8769       return RFAILED;
8770    }
8771
8772    /* Non Critical extension */
8773    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8774    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8775    {
8776       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8777       return RFAILED;
8778    }
8779    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8780    {
8781       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8782       return RFAILED;
8783    }
8784    return ROK;
8785 }
8786
8787 /*******************************************************************
8788  *
8789  * @brief Fill RRC reconfiguration Octet string
8790  *
8791  * @details
8792  *
8793  *    Function : fillRrcReconfigBuf
8794  *
8795  *    Functionality: Fill RRC reconfiguration octet string
8796
8797  *
8798  * @params[in] OCTET_STRING_t buffer
8799  * @return ROK     - success
8800  *         RFAILED - failure
8801  *
8802  * ****************************************************************/
8803 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8804 {
8805    uint8_t          ret = RFAILED;
8806    asn_enc_rval_t   encRetVal;
8807    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8808    rrcReconfig = &rrcRecfg;
8809
8810    while(true)
8811    {
8812       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8813       {
8814          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8815          break;
8816       }
8817
8818       /* Encode RRC Reconfiguration */
8819       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8820       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8821       encBufSize = 0;
8822       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8823
8824       /* Encode results */
8825       if(encRetVal.encoded == ENCODE_FAIL)
8826       {
8827          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8828                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8829          break;
8830       }
8831       else
8832       {
8833          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8834          for(int i=0; i< encBufSize; i++)
8835          {
8836             DU_LOG("%x",encBuf[i]);
8837          }
8838       }
8839
8840       rrcReconfigBuf->size = encBufSize;
8841       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8842       if(!rrcReconfigBuf->buf)
8843       {
8844          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8845          break;
8846       }
8847       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8848       ret = ROK;
8849       break;
8850    }
8851
8852    freeRrcReconfig(rrcReconfig);
8853    return ret;
8854 }
8855
8856 /*******************************************************************
8857  *
8858  * @brief Fill HO preparation information Octet string
8859  *
8860  * @details
8861  *
8862  *    Function : fillHOPreparationInfoBuf
8863  *
8864  *    Functionality: Fill HO preparation information Octet string
8865
8866  *
8867  * @params[in] HandoverPreparationInformation_t buffer
8868  * @return ROK     - success
8869  *         RFAILED - failure
8870  *
8871  * ****************************************************************/
8872 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8873 {
8874    uint8_t          ret = RFAILED;
8875    asn_enc_rval_t   encRetVal;
8876    HandoverPreparationInformationRrc_t hoPrepInfo;
8877    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8878
8879    while(true)
8880    {
8881
8882       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8883       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8884       if(!hoPrepInfo.criticalExtensions.choice.c1)
8885       {
8886          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8887          break;
8888       }
8889       hoPrepInfo.criticalExtensions.choice.c1->present = \
8890          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8891
8892       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8893          sizeof(HandoverPreparationInformationRrc_IEs_t));
8894       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8895       {
8896          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8897          break;
8898       }
8899       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8900
8901       /* Fill UE Capability RAT container list */
8902       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8903       if(ret != ROK)
8904       {
8905          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8906          break;
8907       }
8908
8909       /* Fill Source config */
8910       hoPrepInfoIe->sourceConfig = NULLP;
8911       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8912       if(!hoPrepInfoIe->sourceConfig)
8913       {
8914          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8915          return RFAILED;
8916       }
8917       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8918
8919       if(ret != ROK)
8920       {
8921          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8922          return RFAILED;
8923       }
8924
8925       hoPrepInfoIe->rrm_Config = NULLP;
8926       hoPrepInfoIe->as_Context = NULLP;
8927       hoPrepInfoIe->nonCriticalExtension = NULLP;
8928
8929       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8930       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8931       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8932       encBufSize = 0;
8933       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8934             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8935
8936       /* Encode results */
8937       if(encRetVal.encoded == ENCODE_FAIL)
8938       {
8939          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8940                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8941          break;
8942       }
8943       else
8944       {
8945          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8946          for(int i=0; i< encBufSize; i++)
8947          {
8948             DU_LOG("%x",encBuf[i]);
8949          }
8950       }
8951
8952       hoPrepInfoBuf->size = encBufSize;
8953       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8954       if(!hoPrepInfoBuf->buf)
8955       {
8956          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8957          break;
8958       }
8959       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8960       ret = ROK;
8961       break;
8962    }
8963    freeHOPreparationInfo(&hoPrepInfo);
8964    return ret;
8965 }
8966
8967 /*******************************************************************
8968  *
8969  * @brief Fills CuToDuContainer
8970  *
8971  * @details
8972  *
8973  *    Function : fillCuToDuContainer
8974  *
8975  *    Functionality: Fills CuToDuContainer
8976  *
8977  * @params[in] pointer to CUtoDURRCInformation_t
8978  *
8979  * @return ROK     - success
8980  *         RFAILED - failure
8981  *
8982  ******************************************************************/
8983
8984 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8985 {
8986    uint8_t elementCnt = 0;
8987    uint8_t ret = ROK;
8988    uint8_t idx;
8989
8990    /* UE Capabulity RAT Container List */
8991    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8992    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8993    {
8994       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8995       return RFAILED;
8996    }
8997    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8998
8999    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
9000    if(!rrcMsg->measConfig)
9001    {
9002       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
9003       return RFAILED;
9004    }
9005    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
9006
9007    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9008    {
9009       /* IE extensions */
9010       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9011       if(rrcMsg->iE_Extensions)
9012       {
9013          elementCnt = 1;
9014          rrcMsg->iE_Extensions->list.count = elementCnt;
9015          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
9016
9017          /* Initialize the CUtoDURRCInformation_ExtIEs */
9018          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9019
9020          if(rrcMsg->iE_Extensions->list.array == NULLP)
9021          {
9022             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
9023             ret = RFAILED;
9024          }
9025
9026          for(idx=0; idx<elementCnt; idx++)
9027          {
9028             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
9029             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
9030             {
9031                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
9032                ret = RFAILED;
9033             }
9034          }
9035
9036          idx = 0;
9037 #if 0
9038          /* Cell Group Configuration */
9039          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
9040          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9041          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
9042                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
9043          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
9044          idx++;
9045 #endif
9046          /* Handover Preparation Information */
9047          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
9048          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9049          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
9050                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
9051          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
9052       }
9053    }
9054    return ret;
9055 }
9056 /*******************************************************************
9057  *
9058  * @brief Build the drx cycle
9059  *
9060  * @details
9061  *
9062  *    Function : BuildDrxCycle
9063  *
9064  *    Functionality: Build drx cycle IE
9065  *
9066  * @params[in] pointer to DRXCycle_t
9067  *
9068  * @return ROK     - success
9069  *         RFAILED - failure
9070  *
9071  ******************************************************************/
9072 uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
9073 {
9074    drxCycle->longDRXCycleLength = LongDRXCycleLength_ms40;
9075    CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
9076    if(!drxCycle->shortDRXCycleLength)
9077    {
9078       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleLength");
9079       return RFAILED;
9080    }
9081    *(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
9082
9083    CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
9084    if(!drxCycle->shortDRXCycleTimer)
9085    {
9086       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleTimer");
9087       return RFAILED;
9088    }
9089    *(drxCycle->shortDRXCycleTimer) = 4;
9090    return ROK;
9091 }
9092 /*******************************************************************
9093  *
9094  * @brief Free CuToDuContainer
9095  *
9096  * @details
9097  *
9098  *    Function : FreeCuToDuInfo
9099  *
9100  *    Functionality: Free CuToDuContainer
9101  *
9102  * @params[in] pointer to CUtoDURRCInformation_t
9103  *
9104  * @return ROK     - success
9105  *         RFAILED - failure
9106  *
9107  ******************************************************************/
9108
9109 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9110 {
9111    uint8_t idx, idx2;
9112
9113    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9114    {
9115       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9116          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
9117       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9118    }
9119    if(rrcMsg->iE_Extensions)
9120    {
9121       if(rrcMsg->iE_Extensions->list.array)
9122       {
9123          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
9124          {
9125             if(rrcMsg->iE_Extensions->list.array[idx])
9126             {
9127                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
9128                {
9129                   case ProtocolIE_ID_id_CellGroupConfig:
9130                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9131                      {
9132                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
9133                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
9134
9135                      }
9136                      break;
9137                   default:
9138                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9139                            rrcMsg->iE_Extensions->list.array[idx]->id);
9140                      break;
9141                }
9142             }
9143             break;
9144          }
9145          for(idx2 = 0; idx2 < idx; idx2++)
9146          {
9147             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
9148          }
9149          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9150
9151       }
9152
9153       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9154    }
9155 }
9156 /*******************************************************************
9157  *
9158  * @brief Builds and sends the UE Setup Request
9159  *
9160  * @details
9161  *
9162  *    Function : BuildAndSendUeContextSetupReq
9163  *
9164  *    Functionality: Constructs the UE Setup Request and sends
9165  *                   it to the CU through SCTP.
9166  *
9167  * @params[in]
9168  *
9169  * @return ROK     - success
9170  *         RFAILED - failure
9171  *
9172  * ****************************************************************/
9173 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
9174 {
9175    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
9176    uint8_t   ret= RFAILED, ret1;
9177    uint8_t   elementCnt;
9178    uint8_t   idx, idx1, bufLen, duIdx;
9179    uint32_t  spCellId;
9180    DuDb      *targetDuDb = NULLP;
9181    F1AP_PDU_t           *f1apMsg = NULLP;
9182    UEContextSetupRequest_t *ueSetReq = NULLP;
9183    asn_enc_rval_t encRetVal;        /* Encoder return value */
9184    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9185
9186    while(true)
9187    {
9188       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
9189
9190       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9191       if(f1apMsg == NULLP)
9192       {
9193          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9194          break;
9195       }
9196
9197       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9198       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9199       if(f1apMsg->choice.initiatingMessage == NULLP)
9200       {
9201          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
9202          break;
9203       }
9204
9205       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
9206       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9207       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
9208
9209       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9210
9211       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9212          elementCnt = 7;
9213       else
9214       {
9215 #ifdef NR_DRX
9216          elementCnt = 12;
9217 #else
9218          elementCnt = 11;
9219 #endif
9220       }
9221       ueSetReq->protocolIEs.list.count = elementCnt;
9222       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
9223
9224       /* Initialize the UESetup members */
9225       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
9226
9227       if(ueSetReq->protocolIEs.list.array == NULLP)
9228       {
9229          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
9230          break;
9231       }
9232
9233       for(idx1=0; idx1<elementCnt; idx1++)
9234       {
9235          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
9236          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
9237          {
9238             break;
9239          }
9240       }
9241
9242       idx = 0;
9243
9244       /*GNB CU UE F1AP ID*/
9245       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9246       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9247       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
9248       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
9249
9250       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9251       {
9252          /*GNB DU UE F1AP ID*/
9253          idx++;
9254          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9255          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9256          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
9257          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
9258       }
9259
9260       /*Special Cell ID*/
9261       idx++;
9262       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
9263       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9264       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
9265       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9266       {
9267          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
9268          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
9269          /* Since we are supporting only one cell per DU, accessing 0th index to
9270           * get target cell info */
9271          spCellId = targetDuDb->cellCb[0].nrCellId;
9272       }
9273       else
9274          spCellId = ueCb->cellCb->nrCellId;
9275       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
9276       if(Nrcgiret != ROK)
9277       {
9278          break;
9279       }
9280
9281       /*Served Cell Index*/
9282       idx++;
9283       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9284       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9285       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9286       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9287
9288       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9289       {
9290          /*CellULConfigured*/
9291          idx++;
9292          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9293          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9294          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9295          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9296       }
9297
9298       /*CUtoDURRCContainer*/
9299       idx++;
9300       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9301       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9302       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9303       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9304       {
9305          break;
9306       }
9307
9308       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9309       {
9310          /*Drx cycle*/
9311 #ifdef NR_DRX
9312          idx++;
9313          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_DRXCycle;
9314          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9315          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
9316          if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
9317          {
9318             DU_LOG("\nERROR  -->  F1AP : Failed to build drx cycle");
9319             break;
9320          }
9321 #endif
9322          /*Special Cells to be SetupList*/
9323          idx++;
9324          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9325          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9326          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9327          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9328          if(SplCellListret != ROK)
9329          {
9330             break;
9331          }
9332       }
9333
9334       /*SRBs To Be Setup List*/
9335       idx++;
9336       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9337       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9338       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9339       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9340       if(SrbSetupret != ROK)
9341       {
9342          break;
9343       }
9344
9345       /*DRBs to Be Setup List*/
9346       idx++;
9347       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9348       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9349       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9350       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9351       if(ret1 != ROK)
9352       {
9353          break;
9354       }
9355
9356       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9357       {
9358          /* RRC delivery status request */
9359          idx++;
9360          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9361          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9362          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9363          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9364       }
9365
9366       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9367       idx++;
9368       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9369       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9370       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9371
9372       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9373       bufLen = 4;
9374       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9375       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9376             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9377       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9378       {
9379          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9380          break;
9381       }
9382       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9383       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9384
9385       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9386
9387       /* Encode the F1SetupRequest type as APER */
9388       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9389       encBufSize = 0;
9390       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9391
9392       /* Encode results */
9393       if(encRetVal.encoded == ENCODE_FAIL)
9394       {
9395          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9396                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9397          break;
9398       }
9399       else
9400       {
9401          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9402          for(int i=0; i< encBufSize; i++)
9403          {
9404             DU_LOG("%x",encBuf[i]);
9405          }
9406       }
9407
9408       /* Sending  msg  */
9409       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9410       {
9411          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9412          break;
9413       }
9414       ret = ROK;
9415       break;
9416    }
9417    FreeUeContextSetupReq(f1apMsg);
9418
9419    return ret;
9420 }/* End of BuildAndSendUeContextSetupReq*/
9421
9422 /**********************************************************************
9423  * @brief Function to extractTeId received in UE context setup Response
9424  *
9425  * @details
9426  *
9427  *    Function : extractTeId
9428  *
9429  *    Functionality:
9430  *         - Function to extract TeId
9431  *
9432  * @params[in]
9433  * @return ROK     - success
9434  *         RFAILED - failure
9435  *
9436  **********************************************************************/
9437 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9438 {
9439    uint8_t arrIdx = 0;
9440    uint32_t teId = 0;
9441    GTPTunnel_t *gtpDl = NULLP;
9442
9443    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9444    {
9445       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9446       {
9447          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9448          {
9449             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9450             if(gtpDl->gTP_TEID.size > 0)
9451             {
9452                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9453             }
9454             else
9455                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9456             return(teId);
9457          }
9458       }
9459    }
9460    return teId;
9461 }
9462
9463 /****************************************************************
9464  * @brief Function to add Drb tunnels
9465  *
9466  * @details
9467  *
9468  *    Function : addDrbTunnels
9469  *
9470  *    Functionality:
9471  *         - Function to add Drb tunnels
9472  *
9473  * @params[in]
9474  * @return ROK     - success
9475  *         RFAILED - failure
9476  *
9477  * ****************************************************************/
9478 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9479 {
9480    uint8_t ret = ROK;
9481    EgtpTnlEvt tnlEvt;
9482
9483    if(teId > MAX_TEID || teId < MIN_TEID)
9484    {
9485       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9486    }
9487    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9488    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9489    tnlEvt.lclTeid = teId;
9490    tnlEvt.remTeid = teId;
9491    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9492    if(ret != ROK)
9493    {
9494       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9495    }
9496    return ROK;
9497 }
9498
9499 /****************************************************************
9500  * @brief Function to process Drb Setup List
9501  *
9502  * @details
9503  *
9504  *    Function : procDrbSetupList
9505  *
9506  *    Functionality:
9507  *         - Function to process DRB Setup List
9508  *
9509  * @params[in]
9510  * @return ROK     - success
9511  *         RFAILED - failure
9512  *
9513  * ****************************************************************/
9514 uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
9515 {
9516    uint8_t arrIdx = 0, drbIdx = 0;
9517    uint32_t teId = 0;
9518    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9519
9520    if(drbSetupList != NULLP)
9521    {
9522       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9523       {
9524          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9525          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9526          {
9527             /* extracting teId */
9528             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9529             if(teId > 0)
9530             {
9531                if(addDrbTunnels(duId, teId)== ROK)
9532                {
9533                   DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9534                }
9535                /* As per Spec 38.473, in UE COntext Response, Tunnel information
9536                 * are sent to CU for setting up of Tunnels in DL direction.
9537                 * Search for DRB ID in CU databse */
9538                for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
9539                {
9540                   if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
9541                   {
9542                      fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
9543                      break;
9544                   }
9545                }
9546             }
9547             else
9548                return RFAILED;
9549          }
9550       }
9551    }
9552    return ROK;
9553 }
9554
9555 /****************************************************************
9556  * @brief Function to process Ue Context Setup Response
9557  *
9558  * @details
9559  *
9560  *    Function : procUeContextSetupResponse
9561  *
9562  *    Functionality:
9563  *         - Function to process Ue Context Setup Response
9564  *
9565  * @params[in]
9566  * @return ROK     - success
9567  *         RFAILED - failure
9568  *
9569  * ****************************************************************/
9570 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9571 {
9572    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9573    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9574    DuDb *duDb = NULLP;
9575    CuUeCb *ueCb = NULLP;
9576    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9577    OCTET_STRING_t *duToCuRrcContainer;
9578
9579    SEARCH_DU_DB(duIdx, duId, duDb);
9580    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9581
9582    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9583    {
9584       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9585       {
9586           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9587              {
9588                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9589                break;
9590              }
9591           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9592              {
9593                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9594                 ueCb = &duDb->ueCb[duUeF1apId-1];
9595                 /* If ue context is not present in du db, then create UE context
9596                  * here. This flow is hit in case of UE handover where UE
9597                  * context is created before UE performs RACH on target DU */
9598                 if(ueCb->gnbDuUeF1apId == 0)
9599                 {
9600                    /* Creating UE context in target DU */
9601                    memset(ueCb, 0, sizeof(CuUeCb));
9602                    ueCb->cellCb = &duDb->cellCb[0];
9603                    ueCb->gnbDuUeF1apId = duUeF1apId;
9604                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9605                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9606                    ueCb->hoInfo.targetDuId = duId;
9607                    (duDb->numUe)++;
9608
9609                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9610                    ueCb->cellCb->numUe++;
9611                 }
9612                 break;
9613              }
9614           case ProtocolIE_ID_id_C_RNTI:
9615              {
9616                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9617                 break;
9618              }
9619           case ProtocolIE_ID_id_DRBs_Setup_List:
9620              {
9621                 /* Adding Tunnels for successful DRB */
9622                 procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9623                 break;
9624              }
9625          case ProtocolIE_ID_id_DUtoCURRCInformation:
9626              {
9627                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9628                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9629                    DUtoCURRCInformation.cellGroupConfig;
9630                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9631                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9632                 {
9633                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9634                    return RFAILED;
9635                 }
9636                 break;
9637              }
9638       }
9639    }
9640
9641    /* If the UE is in handover, UE context modification request is to be sent to
9642     * source DU once UE context setup response is received from target DU */
9643    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9644    {
9645       DuDb *srcDuDb = NULLP;
9646       CuUeCb *ueCbInSrcDu = NULLP;
9647
9648       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9649        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9650       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9651       {
9652          /* UE context setup response is received from target DU. Search all
9653           * DUs to find source DU except this target DU Id.*/
9654          if(cuCb.duInfo[duIdx].duId != duId)
9655          {
9656             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9657             {
9658                /* Check following:
9659                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9660                 * received in UE context setup response since CU UE F1AP ID does not
9661                 * change for UE in handover.
9662                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9663                 */
9664                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9665                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9666                {
9667                   srcDuDb = &cuCb.duInfo[duIdx];
9668                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9669
9670                   /* Store source DU info in the new UE context created in
9671                    * tareget DU */
9672                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9673
9674                   /* Copy the received container to UeCb */
9675                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9676
9677                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9678                   {
9679                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9680                      return RFAILED;
9681                   }
9682                   break;
9683                }
9684             }
9685          }
9686          if(srcDuDb && ueCbInSrcDu)
9687             break;
9688       }
9689    }
9690    else
9691    {
9692       ueCb->f1apMsgDb.dlRrcMsgCount++;
9693       rrcMsgType = setDlRRCMsgType(ueCb);
9694
9695       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9696       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9697       {
9698          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9699          return RFAILED;
9700       }
9701    }
9702
9703    return ROK;
9704 }
9705
9706 /****************************************************************
9707  * @brief Function to process Ul Rrc Msg received from DU
9708  *
9709  * @details
9710  *
9711  *    Function : procUlRrcMsg
9712  *
9713  *    Functionality:
9714  *         - Function to process Ul Rrc Msg received from DU
9715  *
9716  * @params[in]
9717  * @return ROK     - success
9718  *         RFAILED - failure
9719  *
9720  * ****************************************************************/
9721
9722 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9723 {
9724    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9725    uint8_t  *rrcContainer = NULLP;
9726    uint16_t rrcContLen = 0;
9727    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9728    DuDb     *duDb = NULLP;
9729    CuUeCb   *ueCb = NULLP;
9730    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9731
9732    ret = ROK;
9733    SEARCH_DU_DB(duIdx, duId, duDb);
9734    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9735
9736    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9737    {
9738       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9739       {
9740          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9741             {
9742                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9743                break;
9744             }
9745          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9746             {
9747                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9748                break;
9749             }
9750          case ProtocolIE_ID_id_SRBID:
9751             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9752             break;
9753
9754          case ProtocolIE_ID_id_RRCContainer:
9755             {
9756                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9757                CU_ALLOC(rrcContainer, rrcContLen);
9758                if(!rrcContainer)
9759                {
9760                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9761                   return RFAILED;
9762                }
9763                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9764
9765                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9766                {
9767                   uint8_t ueIdx = 0;
9768                   uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.sourceDuId;
9769                   DuDb *srcDuDb = NULLP;
9770
9771                   /* In target DU DB, mark UE as active and delete HO info */
9772                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9773                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9774
9775                   /* Release UE context in source DU because the UE is now
9776                    * attached to target DU */
9777                   SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9778                   for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9779                   {
9780                      if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9781                      {
9782                         ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9783                         if(ret != ROK)
9784                         {
9785                            DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9786                         }
9787                         break;
9788                      }
9789                   }
9790                   return ret;
9791                }
9792                break;
9793             }
9794
9795          default:
9796             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9797             break;
9798       }
9799    }
9800
9801    if(srbId == 1)
9802    {
9803       ueCb = &duDb->ueCb[duUeF1apId-1];
9804       ueCb->f1apMsgDb.dlRrcMsgCount++;
9805       rrcMsgType = setDlRRCMsgType(ueCb);
9806       if(rrcMsgType == RRC_SETUP_COMPLETE)
9807       {
9808          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for NAS Security Mode Command");
9809          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9810       }
9811       if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
9812       {
9813          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Security Mode Command");
9814          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9815       }
9816       else if(rrcMsgType == RRC_SECURITY_MODE_COMPLETE)
9817       {
9818          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9819          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9820       }
9821       else if(rrcMsgType == REGISTRATION_COMPLETE)
9822       {
9823          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9824          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9825       }
9826       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9827       {
9828          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9829          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9830       }
9831    }
9832    return ret;
9833 }
9834
9835 /****************************************************************
9836  * @brief Build And Send F1ResetAck
9837  *
9838  * @details
9839  *
9840  *    Function : FreeF1ResetAck
9841  *
9842  *    Functionality:
9843  *         - Build And Send  F1ResetRSP
9844  *
9845  *  @params[in]
9846  * @return ROK     - success
9847  *         RFAILED - failure
9848  *
9849  * ****************************************************************/
9850 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9851 {
9852    uint8_t idx;
9853    ResetAcknowledge_t *f1ResetAck;
9854
9855    if(f1apMsg)
9856    {
9857       if(f1apMsg->choice.successfulOutcome)
9858       {
9859          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9860
9861          if(f1ResetAck->protocolIEs.list.array)
9862          {
9863             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9864             {
9865                if(f1ResetAck->protocolIEs.list.array[idx])
9866                {
9867                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9868                }
9869             }
9870             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9871          }
9872          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9873       }
9874       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9875    }
9876 }
9877
9878 /****************************************************************
9879  * @brief Build And Send F1ResetAck
9880  *
9881  * @details
9882  *
9883  *    Function : BuildAndSendF1ResetAck
9884  *
9885  *    Functionality:
9886  *         - Build And Send  F1ResetRSP
9887  *
9888  *  @params[in]
9889  * @return ROK     - success
9890  *         RFAILED - failure
9891  *
9892  * ****************************************************************/
9893
9894 uint8_t BuildAndSendF1ResetAck()
9895 {
9896    uint8_t                idx = 0;
9897    uint8_t                elementCnt = 0;
9898    uint8_t                ret = RFAILED;
9899    F1AP_PDU_t             *f1apMsg = NULL;
9900    ResetAcknowledge_t     *f1ResetAck = NULLP;
9901    asn_enc_rval_t         encRetVal;
9902    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9903
9904    do{
9905       /* Allocate the memory for F1ResetRequest_t */
9906       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9907       if(f1apMsg == NULLP)
9908       {
9909          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9910          break;
9911       }
9912
9913       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9914
9915       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9916       if(f1apMsg->choice.successfulOutcome == NULLP)
9917       {
9918          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9919          break;
9920       }
9921
9922       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9923       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9924       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9925       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9926
9927       elementCnt = 1;
9928
9929       f1ResetAck->protocolIEs.list.count = elementCnt;
9930       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9931
9932       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9933       if(f1ResetAck->protocolIEs.list.array == NULLP)
9934       {
9935          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9936          break;
9937       }
9938
9939       for(idx=0; idx<elementCnt; idx++)
9940       {
9941          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9942          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9943          {
9944             break;
9945          }
9946       }
9947       /*TransactionID*/
9948       idx = 0;
9949       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9950       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9951       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9952       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9953
9954       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9955
9956       /* Encode the F1SetupRequest type as UPER */
9957       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9958       encBufSize = 0;
9959       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9960
9961       /* Check encode results */
9962       if(encRetVal.encoded == ENCODE_FAIL)
9963       {
9964          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9965                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9966          break;
9967       }
9968       else
9969       {
9970          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9971          for(int i=0; i< encBufSize; i++)
9972          {
9973             DU_LOG("%x",encBuf[i]);
9974          }
9975       }
9976
9977       /* Sending msg */
9978       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9979       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9980       {
9981          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9982          break;
9983       }
9984
9985       ret = ROK;
9986       break;
9987    }while(true);
9988
9989    FreeF1ResetAck(f1apMsg);
9990    return ret;
9991 }
9992
9993 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9994 {
9995    uint8_t arrIdx =0;
9996
9997    if(ulInfo->list.array)
9998    {
9999       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
10000       {
10001          if(ulInfo->list.array[arrIdx])
10002          {
10003             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
10004             {
10005                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
10006                {
10007                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
10008                   {
10009                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10010                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10011                      gTPTunnel->gTP_TEID.size);
10012                   }
10013                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10014                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10015                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10016                }
10017                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10018                sizeof(GTPTunnel_t));
10019             }
10020             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10021          }
10022       }
10023       CU_FREE(ulInfo->list.array,ulInfo->list.size);
10024    }
10025 }
10026
10027 /*******************************************************************
10028 *
10029 * @brief Deletes the EGTP tunnel
10030 *
10031 * @details
10032 *
10033 *    Function : deleteEgtpTunnel
10034 *
10035 *    Functionality: Deletes the EGTP tunnel
10036 *
10037 * @params[in] uint8_t *buf
10038 *
10039 * @return ROK     - success
10040 *         RFAILED - failure
10041 *
10042 * ****************************************************************/
10043 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
10044 {
10045    uint32_t teId = 0;
10046    EgtpTnlEvt tnlEvt;
10047
10048    teIdStringToInt(buf, &teId);
10049    if(teId > MAX_TEID || teId < MIN_TEID)
10050    {
10051       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
10052       return RFAILED;
10053    }
10054    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
10055    tnlEvt.action = EGTP_TNL_MGMT_DEL;
10056    tnlEvt.lclTeid = teId;
10057    tnlEvt.remTeid = teId;
10058    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
10059    {
10060       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
10061    }
10062    return ROK;
10063 }
10064
10065 /*******************************************************************
10066 *
10067 * @brief Builds the Uplink Tunnel Info
10068 *
10069 * @details
10070 *
10071 *    Function : BuildUlTnlInfoforSetupMod
10072 *
10073 *    Functionality: Constructs the UL TnlInfo For DRB list
10074 *
10075 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10076 *
10077 * @return ROK     - success
10078 *         RFAILED - failure
10079 *
10080 * ****************************************************************/
10081 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
10082 {
10083    uint8_t arrIdx;
10084    uint8_t ulCnt;
10085
10086    ulCnt = 1;
10087    ulInfo->list.count = ulCnt;
10088    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
10089    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
10090    if(ulInfo->list.array == NULLP)
10091    {
10092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10093       return RFAILED;
10094    }
10095    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
10096    {
10097       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10098       if(ulInfo->list.array[arrIdx] == NULLP)
10099       {
10100          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10101          return RFAILED;
10102       }
10103    }
10104
10105    arrIdx = 0;
10106    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
10107    UPTransportLayerInformation_PR_gTPTunnel;
10108
10109    /*GTP TUNNEL*/
10110    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10111          sizeof(GTPTunnel_t));
10112    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
10113    {
10114       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10115       return RFAILED;
10116    }
10117    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10118       transportLayerAddress.size        = 4*sizeof(uint8_t);
10119    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10120          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10121          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10122    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10123          transportLayerAddress.buf == NULLP)
10124    {
10125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10126       return RFAILED;
10127    }
10128
10129    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10130       transportLayerAddress.buf[0] = 192;
10131    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10132       transportLayerAddress.buf[1] = 168;
10133    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10134       transportLayerAddress.buf[2] = 130;
10135    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10136       transportLayerAddress.buf[3] = 82;
10137    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10138       transportLayerAddress.bits_unused = 0;
10139
10140    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
10141    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
10142    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
10143    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
10144
10145    /*GTP TEID*/
10146    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
10147       = 4 * sizeof(uint8_t);
10148    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10149          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10150          gTPTunnel->gTP_TEID.size);
10151    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10152          == NULLP)
10153    {
10154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10155       return RFAILED;
10156    }
10157    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10158       gTP_TEID.buf[0] = 0;
10159    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10160       gTP_TEID.buf[1] = 0;
10161    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10162       gTP_TEID.buf[2] = 0;
10163    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
10164    {
10165      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
10166       * fetched based on the Drb Id */
10167
10168      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
10169       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
10170                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
10171    }
10172    else
10173    {
10174       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10175         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
10176    }
10177
10178    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
10179    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
10180    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
10181    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
10182    return ROK;
10183 }/*End of BuildULTnlInfo*/
10184
10185 /*******************************************************************
10186 *
10187 * @brief freeing the DRB item
10188 *
10189 * @details
10190 *
10191 *    Function : FreeDrbItem
10192 *
10193 *    Functionality: freeing the DRB item
10194 *
10195 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10196 *
10197 * @return ROK     - success
10198 *         RFAILED - failure
10199 *
10200 * ****************************************************************/
10201
10202 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
10203 {
10204    uint8_t arrIdx =0;
10205    SNSSAI_t *snssai =NULLP;
10206    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10207
10208    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10209    switch(drbItem->qoSInformation.present)
10210    {
10211       case QoSInformation_PR_NOTHING:
10212          break;
10213       case QoSInformation_PR_eUTRANQoS:
10214          {
10215             if(drbItem->qoSInformation.choice.eUTRANQoS)
10216             {
10217                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10218             }
10219             break;
10220          }
10221       case QoSInformation_PR_choice_extension:
10222          {
10223             if(drbItem->qoSInformation.choice.choice_extension)
10224             {
10225                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10226
10227                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10228                if(snssai->sST.buf)
10229                {
10230                   CU_FREE(snssai->sST.buf,snssai->sST.size);
10231                }
10232                if(snssai->sD)
10233                {
10234                   if(snssai->sD->buf)
10235                   {
10236                      CU_FREE(snssai->sD->buf,snssai->sD->size);
10237                   }
10238                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10239                }
10240
10241                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10242                if(flowMap->list.array)
10243                {
10244                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10245                   {
10246                      if(flowMap->list.array[arrIdx] )
10247                      {
10248                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10249                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10250                      }
10251                   }
10252                   CU_FREE(flowMap->list.array,flowMap->list.size);
10253                }
10254
10255                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10256             }
10257             break;
10258          }
10259
10260    }
10261    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10262    if(drbItem->uLConfiguration)
10263    {
10264       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10265    }
10266 }
10267
10268 /*******************************************************************
10269 *
10270 * @brief filling the DRB setup Mod item
10271 *
10272 * @details
10273 *
10274 *    Function : FillDrbItemToSetupMod
10275 *
10276 *    Functionality: filling the DRB setup Mod item
10277 *
10278 *
10279 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10280 *
10281 * @return ROK     - success
10282 *         RFAILED - failure
10283 *
10284 * ****************************************************************/
10285
10286 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
10287 {
10288    uint8_t ret = ROK;
10289
10290    /*Drb Id */
10291    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
10292    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
10293
10294    /*qoSInformation*/
10295    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10296
10297    switch(drbItem->qoSInformation.present)
10298    {
10299       case QoSInformation_PR_NOTHING:
10300       {
10301          break;
10302       }
10303       case QoSInformation_PR_eUTRANQoS:
10304       {
10305
10306          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10307          if(drbItem->qoSInformation.choice.eUTRANQoS)
10308          {
10309             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10310             return RFAILED;
10311          }
10312          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10313          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10314             PriorityLevel_no_priority;
10315
10316          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10317             Pre_emptionCapability_may_trigger_pre_emption;
10318
10319          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10320             Pre_emptionVulnerability_pre_emptable;
10321
10322          break;
10323       }
10324       case QoSInformation_PR_choice_extension:
10325       {
10326          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10327          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10328          {
10329             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10330             return RFAILED;
10331          }
10332
10333          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10334          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10335          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10336          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10337            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10338          if(ret != ROK)
10339          {
10340             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10341             return RFAILED;
10342          }
10343
10344          /*SNSSAI*/
10345          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10346                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10347          if(ret != ROK)
10348          {
10349             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10350             return RFAILED;
10351          }
10352
10353          /*Flows mapped to DRB List*/
10354          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10355                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10356           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10357          if(ret != ROK)
10358          {
10359             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10360             return RFAILED;
10361          }
10362       }
10363    }
10364
10365    /*ULUPTNLInformation To Be Setup List*/
10366    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10367       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10368    if(ret != ROK)
10369    {
10370       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10371       return RFAILED;
10372    }
10373
10374    /*RLCMode*/
10375    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10376    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10377
10378    ueCb->numDrb++;
10379    return ROK;
10380 }
10381
10382 /*******************************************************************
10383 *
10384 * @brief Builds the DRB to be Setup Mod ItemIes
10385 *
10386 * @details
10387 *
10388 *    Function : FillDrbItemList
10389 *
10390 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10391 *
10392 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10393 *
10394 * @return ROK     - success
10395 *         RFAILED - failure
10396 *
10397 * ****************************************************************/
10398
10399 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10400 {
10401    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10402    drbItemIe->criticality = Criticality_reject;
10403    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10404
10405    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10406    {
10407       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10408       return RFAILED;
10409    }
10410    return ROK;
10411 }
10412 /*******************************************************************
10413 *
10414 * @brief free the DRB to be Setup Mod list
10415 *
10416 * @details
10417 *
10418 *    Function : FreeDrbToBeSetupModList
10419 *
10420 *    Functionality: free the DRB to be Setup Mod list
10421 *
10422 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10423 *
10424 * @return ROK     - success
10425 *         RFAILED - failure
10426 *
10427 * ****************************************************************/
10428 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10429 {
10430    uint8_t arrIdx =0;
10431    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10432
10433    if(drbSet->list.array)
10434    {
10435       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10436       {
10437          if(drbSet->list.array[arrIdx] != NULLP)
10438          {
10439             if(arrIdx == 0)
10440             {
10441                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10442                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10443             }
10444             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10445          }
10446       }
10447       CU_FREE(drbSet->list.array, drbSet->list.size);
10448    }
10449
10450 }
10451
10452 /*******************************************************************
10453 *
10454 * @brief Builds the DRB to be Setup Mod list
10455 *
10456 * @details
10457 *
10458 *    Function : BuildDrbToBeSetupList
10459 *
10460 *    Functionality: Constructs the DRB to be Setup Mod list
10461 *
10462 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10463 *
10464 * @return ROK     - success
10465 *         RFAILED - failure
10466 *
10467 * ****************************************************************/
10468
10469 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10470 {
10471    uint8_t ret = ROK;
10472    uint8_t arrIdx =0;
10473    uint8_t drbCnt =0;
10474
10475    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10476    drbSet->list.count = drbCnt;
10477    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10478    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10479    if(drbSet->list.array == NULLP)
10480    {
10481       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10482       return  RFAILED;
10483    }
10484
10485    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10486    {
10487       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10488       if(drbSet->list.array[arrIdx] == NULLP)
10489       {
10490          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10491          return  RFAILED;
10492       }
10493
10494       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10495       if(ret != ROK)
10496       {
10497          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10498       }
10499    }
10500
10501    return ret;
10502 }
10503
10504 /*******************************************************************
10505 *
10506 * @brief Filling the DRB to be modified item
10507 *
10508 * @details
10509 *
10510 *    Function : FillDrbToBeModItem
10511 *
10512 *    Functionality: filling the DRB to be modified item
10513 *
10514 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10515 *
10516 * @return ROK     - success
10517 *         RFAILED - failure
10518 *
10519 * ****************************************************************/
10520
10521 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10522 {
10523    uint8_t ret = ROK;
10524    uint drbIdx=0;
10525    DrbInfo *drbToBeMod;
10526
10527    /*Drb Id */
10528    drbItem->dRBID = DRB2 + arrIdx;
10529
10530    /* Search for DRB ID in CU databse */
10531    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10532    {
10533       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10534       {
10535          drbToBeMod = &ueCb->drbList[drbIdx];
10536          break;
10537       }
10538    }
10539
10540    /*qoSInformation*/
10541    drbItem->qoSInformation = NULLP;
10542    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10543    if(drbItem->qoSInformation != NULLP)
10544    {
10545       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10546
10547       switch(drbItem->qoSInformation->present)
10548       {
10549          case QoSInformation_PR_NOTHING:
10550             {
10551                break;
10552             }
10553          case QoSInformation_PR_eUTRANQoS:
10554             {
10555
10556                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10557                if(drbItem->qoSInformation->choice.eUTRANQoS)
10558                {
10559                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10560                   return RFAILED;
10561                }
10562                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10563                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10564                   PriorityLevel_no_priority;
10565
10566                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10567                   Pre_emptionCapability_may_trigger_pre_emption;
10568
10569                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10570                   Pre_emptionVulnerability_pre_emptable;
10571
10572                break;
10573             }
10574          case QoSInformation_PR_choice_extension:
10575             {
10576                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10577                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10578                {
10579                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10580                   return RFAILED;
10581                }
10582
10583                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10584                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10585                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10586                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10587                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10588                if(ret != ROK)
10589                {
10590                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10591                   return RFAILED;
10592                }
10593
10594                /*SNSSAI*/
10595                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10596                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10597                if(ret != ROK)
10598                {
10599                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10600                   return RFAILED;
10601                }
10602
10603                /*Flows mapped to DRB List*/
10604                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10605                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10606                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10607                if(ret != ROK)
10608                {
10609                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10610                   return RFAILED;
10611                }
10612             }
10613       }
10614    }/* End of QoS */
10615
10616    /*ULUPTNLInformation To Be Setup List*/
10617    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10618             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10619    if(ret != ROK)
10620    {
10621       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10622       return RFAILED;
10623    }
10624    return ROK;
10625 }
10626
10627 /*******************************************************************
10628 *
10629 * @brief Builds the DRB to be modified Item IE
10630 *
10631 * @details
10632 *
10633 *    Function : FillDrbToBeModItemList
10634 *
10635 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10636 *
10637 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10638 *
10639 * @return ROK     - success
10640 *         RFAILED - failure
10641 *
10642 * ****************************************************************/
10643
10644 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10645 {
10646    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10647    drbItemIe->criticality = Criticality_reject;
10648    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10649    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10650    {
10651       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10652       return RFAILED;
10653    }
10654
10655    return ROK;
10656 }
10657
10658 /*******************************************************************
10659 *
10660 * @brief Builds the DRB to be modified list
10661 *
10662 * @details
10663 *
10664 *    Function : BuildDrbToBeModList
10665 *
10666 *    Functionality: Constructs the DRB to be modified list
10667 *
10668 * @params[in] DRBs_ToBeModified_List_t *drbSet
10669 *
10670 * @return ROK     - success
10671 *         RFAILED - failure
10672 *
10673 * ****************************************************************/
10674
10675 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10676 {
10677    uint8_t ret = ROK;
10678    uint8_t arrIdx =0;
10679    uint8_t drbCnt =0;
10680
10681    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10682    drbSet->list.count = drbCnt;
10683    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10684    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10685    if(drbSet->list.array == NULLP)
10686    {
10687       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10688       return  RFAILED;
10689    }
10690    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10691    {
10692       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10693       if(drbSet->list.array[arrIdx] == NULLP)
10694       {
10695          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10696          return  RFAILED;
10697       }
10698
10699       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10700       if(ret != ROK)
10701       {
10702          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10703       }
10704    }
10705
10706    return ret;
10707 }
10708
10709 /*******************************************************************
10710 *
10711 * @brief freeing the DRB  item
10712 *
10713 * @details
10714 *
10715 *    Function : FreeModifiedDrbItem
10716 *
10717 *    Functionality: freeing the DRB 2 item
10718 *
10719 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10720 *
10721 * @return ROK     - success
10722 *         RFAILED - failure
10723 *
10724 * ****************************************************************/
10725
10726 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10727 {
10728    uint8_t arrIdx =0;
10729    SNSSAI_t *snssai =NULLP;
10730    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10731
10732    if(drbItem->qoSInformation != NULLP)
10733    {
10734       switch(drbItem->qoSInformation->present)
10735       {
10736          case QoSInformation_PR_NOTHING:
10737             break;
10738          case QoSInformation_PR_eUTRANQoS:
10739             {
10740                if(drbItem->qoSInformation->choice.eUTRANQoS)
10741                {
10742                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10743                }
10744                break;
10745             }
10746          case QoSInformation_PR_choice_extension:
10747             {
10748                if(drbItem->qoSInformation->choice.choice_extension)
10749                {
10750                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10751
10752                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10753                   if(snssai->sST.buf)
10754                   {
10755                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10756                   }
10757                   if(snssai->sD)
10758                   {
10759                      if(snssai->sD->buf)
10760                      {
10761                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10762                      }
10763                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10764                   }
10765
10766                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10767                   if(flowMap->list.array)
10768                   {
10769                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10770                      {
10771                         if(flowMap->list.array[arrIdx] )
10772                         {
10773                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10774                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10775                         }
10776                      }
10777                      CU_FREE(flowMap->list.array,flowMap->list.size);
10778                   }
10779
10780                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10781                }
10782                break;
10783             }
10784       }
10785    }
10786    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10787    if(drbItem->uLConfiguration)
10788    {
10789       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10790    }
10791 }
10792
10793 /*******************************************************************
10794 *
10795 * @brief free the DRB to be modfified list
10796 *
10797 * @details
10798 *
10799 *    Function : FreeDrbToBeModifiedList
10800 *
10801 *    Functionality: free the DRB to be Setup Mod list
10802 *
10803 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10804 *
10805 * @return ROK     - success
10806 *         RFAILED - failure
10807 *
10808 * ****************************************************************/
10809 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10810 {
10811    uint8_t arrIdx =0;
10812    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10813
10814    if(drbSet->list.array)
10815    {
10816       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10817       {
10818          if(drbSet->list.array[arrIdx] != NULLP)
10819          {
10820             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10821             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10822             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10823          }
10824       }
10825       CU_FREE(drbSet->list.array, drbSet->list.size);
10826    }
10827
10828 }
10829
10830 /*******************************************************************
10831  *
10832  * @brief  free the UeContextModification Request
10833  *
10834  * @details
10835  *
10836  *    Function : FreeUeContextModicationRequest
10837  *
10838  *    Functionality : deallocation of memory allocated in UeContextModiification
10839  request
10840  *
10841  * @params[in] F1AP_PDU_t *f1apMsg
10842  *
10843  * @return void
10844 *
10845 * ****************************************************************/
10846 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10847 {
10848    uint8_t arrIdx =0 , ieId=0;
10849    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10850
10851    if(f1apMsg)
10852    {
10853       if(f1apMsg->choice.initiatingMessage)
10854       {
10855          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10856          if(ueContextModifyReq->protocolIEs.list.array)
10857          {
10858             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10859             {
10860                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10861                {
10862                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10863                   switch(ieId)
10864                   {
10865                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10866                         break;
10867                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10868                         break;
10869                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10870                         {
10871                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10872                                  choice.DRBs_ToBeSetupMod_List);
10873                            break;
10874                         }
10875                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10876                         {
10877                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10878                                  choice.DRBs_ToBeModified_List);
10879                            break;
10880                         }
10881                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10882                         break;
10883                     case ProtocolIE_ID_id_RRCContainer:
10884                     {
10885                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10886                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10887                     }
10888
10889                   }
10890                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10891                }
10892             }
10893             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10894          }
10895          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10896       }
10897       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10898    }
10899 }
10900
10901 /*******************************************************************
10902  *
10903  * @brief Builds the Ue Context Modification Req
10904  *
10905  * @details
10906  *
10907  *    Function : BuildAndSendUeContextModificationReq
10908  *
10909  *    Functionality: Constructs the Ue Context Modification Req
10910  *
10911  * @params[in]
10912  *
10913  * @return ROK     - success
10914  *         RFAILED - failure
10915  *
10916  * ****************************************************************/
10917 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10918 {
10919    uint8_t    ieIdx = 0;
10920    uint8_t    elementCnt = 0;
10921    uint8_t    ret = RFAILED;
10922    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10923    F1AP_PDU_t *f1apMsg = NULLP;
10924    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10925    asn_enc_rval_t         encRetVal;
10926    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10927    while(1)
10928    {
10929       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10930       if(f1apMsg == NULLP)
10931       {
10932          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10933          break;
10934       }
10935
10936       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10937
10938       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10939       if(f1apMsg->choice.initiatingMessage == NULLP)
10940       {
10941          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10942          break;
10943       }
10944       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10945       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10946       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10947
10948       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10949
10950       if(action == MODIFY_UE)
10951          elementCnt = 4;
10952       else if(action == QUERY_CONFIG)
10953          elementCnt = 3;
10954       else if(action == RRC_RECONFIG_COMPLETE_IND)
10955          elementCnt = 3;
10956       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10957          elementCnt = 5;
10958
10959       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10960       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10961
10962       /* Initialize the UE context modification members */
10963       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10964       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10965       {
10966          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10967          break;
10968       }
10969
10970       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10971       {
10972          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10973          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10974          {
10975             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10976             break;
10977          }
10978       }
10979
10980       ieIdx=0;
10981       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10982       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10983       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10984                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10985       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10986
10987       ieIdx++;
10988       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10989       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10990       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10991                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10992       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10993
10994       if(action == MODIFY_UE)
10995       {
10996          /* DRB to be setup list */
10997          ieIdx++;
10998          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10999          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11000          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11001                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
11002          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11003                   value.choice.DRBs_ToBeSetupMod_List));
11004
11005          /* DRB to be modified list */
11006          ieIdx++;
11007          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
11008          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11009          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11010                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
11011          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11012                   value.choice.DRBs_ToBeModified_List));
11013
11014          /* TODO: DRB to be release list */
11015
11016          if(ret != ROK)
11017          {
11018             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
11019             break;
11020          }
11021
11022          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
11023       }
11024       else if(action == QUERY_CONFIG)
11025       {
11026          ieIdx++;
11027          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
11028          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11029          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11030             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
11031          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
11032       }
11033       else if(action == RRC_RECONFIG_COMPLETE_IND)
11034       {
11035          ieIdx++;
11036          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
11037          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11038          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11039             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
11040          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
11041             RRCReconfigurationCompleteIndicator_true;
11042       }
11043       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11044       {
11045          ieIdx++;
11046          if(action == STOP_DATA_TX)
11047          {
11048             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11049             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11050             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11051             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11052             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11053             TransmissionActionIndicator_stop;
11054          }
11055          else if (action == RESTART_DATA_TX)
11056          {
11057             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11058             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11059             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11060             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11061             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11062             TransmissionActionIndicator_restart;
11063          }
11064
11065          ieIdx++;
11066          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11067          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11068          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11069          UEContextModificationRequestIEs__value_PR_RRCContainer;
11070          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
11071          {
11072             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
11073             return RFAILED;
11074          }
11075
11076          /* RRC delivery status request */
11077          ieIdx++;
11078          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
11079          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11080          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
11081          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
11082       }
11083
11084       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11085
11086       /* Encode the F1SetupRequest type as APER */
11087       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11088       encBufSize = 0;
11089       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11090
11091       /* Encode results */
11092       if(encRetVal.encoded == ENCODE_FAIL)
11093       {
11094          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
11095                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11096          break;
11097       }
11098       else
11099       {
11100          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
11101 #if 0
11102          /* This for loop was going into an infinite loop even though encBufSize
11103           * has a small value. Hence commented this
11104           */
11105          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11106          {
11107             DU_LOG("%x",encBuf[ieIdx]);
11108          }
11109 #endif
11110       }
11111
11112       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11113       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11114       {
11115          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
11116          break;
11117       }
11118
11119       ret = ROK;
11120       break;
11121
11122    }
11123    FreeUeContextModicationRequest(f1apMsg);
11124    return ret;
11125 }
11126
11127 /*****************************************************************i
11128  *
11129 * @brief Free memory allocated for UE Context Release Command
11130 *
11131 * @details
11132 *
11133 *    Function : FreeUeContextReleaseCommand
11134 *
11135 *    Functionality:
11136 *         - Free memory allocated for UE Context Release Command
11137 *
11138 * @params[in] F1AP_PDU_t *f1apMsg
11139 * @return void
11140 *
11141 * *************************************************************/
11142 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
11143 {
11144    uint8_t ieIdx;
11145    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
11146
11147    if(f1apMsg)
11148    {
11149       if(f1apMsg->choice.initiatingMessage)
11150       {
11151          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11152          if(ueReleaseCommand->protocolIEs.list.array)
11153          {
11154             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
11155             {
11156                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11157             }
11158             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
11159          }
11160          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11161       }
11162       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11163    }
11164 }
11165 /*******************************************************************
11166  *
11167  * @brief Builds the Ue Context Release Command
11168  *
11169  * @details
11170 *
11171 *    Function : BuildAndSendUeContextReleaseCommand
11172 *
11173 *    Functionality: Constructs the Ue Context Release Command
11174 *
11175 * @params[in]
11176 *
11177 * @return ROK     - success
11178 *         RFAILED - failure
11179 *
11180 * ****************************************************************/
11181 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
11182 {
11183    bool       memAllocFailed = false;
11184    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
11185    DuDb *duDb;
11186    CuUeCb *ueCb;
11187    F1AP_PDU_t *f1apMsg = NULLP;
11188    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
11189
11190    asn_enc_rval_t         encRetVal;
11191    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
11192
11193    while(true)
11194    {
11195       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11196       if(f1apMsg == NULLP)
11197       {
11198          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
11199          break;
11200       }
11201
11202       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11203
11204       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11205       if(f1apMsg->choice.initiatingMessage == NULLP)
11206       {
11207          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
11208          break;
11209       }
11210       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
11211       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11212       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
11213
11214       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11215
11216       SEARCH_DU_DB(duIdx, duId, duDb);
11217       ueCb = &duDb->ueCb[duUeF1apId-1];
11218       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11219          elementCnt = 3;
11220       else
11221          elementCnt = 4;
11222
11223       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
11224       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
11225
11226       /* Initialize the UE context modification members */
11227       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
11228       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
11229       {
11230          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
11231          break;
11232       }
11233
11234       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11235       {
11236          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11237          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
11238          {
11239             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
11240             memAllocFailed = true;
11241             break;
11242          }
11243       }
11244
11245       if(memAllocFailed == true)
11246       {
11247          break;
11248       }
11249
11250       ieIdx=0;
11251       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11252       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11253       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11254       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
11255       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
11256
11257       ieIdx++;
11258       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11259       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11260       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11261       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
11262       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
11263
11264       /* Cause of UE context release */
11265       ieIdx++;
11266       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
11267       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11268       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11269                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
11270       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11271       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
11272                                                                                                      CauseRadioNetwork_normal_release;
11273       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11274       {
11275          /* RRC Container for RRC release */
11276          ieIdx++;
11277          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11278          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11279          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11280                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
11281          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
11282          bufLen =7;
11283          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
11284          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
11285                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
11286          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
11287          {
11288             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
11289             break;
11290          }
11291          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
11292          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
11293       }
11294       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11295
11296       /* Encode the UE Context Release Command type as APER */
11297       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11298       encBufSize = 0;
11299       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11300             encBuf);
11301
11302       /* Encode results */
11303       if(encRetVal.encoded == ENCODE_FAIL)
11304       {
11305          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11306                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11307          break;
11308       }
11309       else
11310       {
11311          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
11312          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11313          {
11314             DU_LOG("%x",encBuf[ieIdx]);
11315          }
11316       }
11317
11318       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11319       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11320       {
11321          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11322          break;
11323       }
11324
11325       ret = ROK;
11326       break;
11327
11328    }
11329    FreeUeContextReleaseCommand(f1apMsg);
11330    return ret;
11331 }
11332 /*******************************************************************
11333 *
11334 * @brief process Ue context release request
11335 *
11336 * @details
11337 *
11338 *    Function : procUeContextReleaseReq
11339 *
11340 *    Functionality:
11341 *         - process Ue context release request
11342 *
11343 * @params[in] F1AP_PDU_t *f1apMsg
11344 * @return ROK     - success
11345 *         RFAILED - failure
11346 *
11347 * ****************************************************************/
11348 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11349 {
11350    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11351
11352    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11353    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11354
11355    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11356    {
11357       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11358       {
11359          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11360             {
11361                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11362                break;
11363             }
11364          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11365             {
11366                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11367                break;
11368             }
11369          default:
11370               break;
11371       }
11372    }
11373
11374    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11375    {
11376       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11377       return RFAILED;
11378    }
11379    return ROK;
11380 }
11381 /*******************************************************************
11382 *
11383 * @brief processing of Gnb-DU config update
11384 *
11385 * @details
11386 *
11387 *    Function : procGnbDuUpdate
11388 *
11389 *    Functionality:
11390 *         - processing of Gnb-DU config update
11391 *
11392 * @params[in] F1AP_PDU_t *f1apMsg
11393 * @return ROK     - success
11394 *         RFAILED - failure
11395 *
11396 * ****************************************************************/
11397 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11398 {
11399    bool cellToBeDelete = false;
11400    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11401    uint16_t nrCellId;
11402    DuDb *duDb;
11403    CuCellCb *cellCb;
11404    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11405
11406    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11407    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11408    {
11409       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11410       {
11411          case ProtocolIE_ID_id_TransactionID:
11412             break;
11413          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11414             break;
11415          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11416             {
11417                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11418                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11419                   Served_Cells_To_Delete_List.list.array[0];
11420                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11421                cellToBeDelete = true;
11422                break;
11423             }
11424          case ProtocolIE_ID_id_gNB_DU_ID:
11425             break;
11426       }
11427    }
11428    if(BuildAndSendDUUpdateAck(duId) != ROK)
11429    {
11430       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11431       return RFAILED;
11432    }
11433 #if 0
11434    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11435     * commented this trigger for now */
11436
11437    if(cellToBeDelete == false)
11438    {
11439       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11440       if(BuildAndSendF1ResetReq() != ROK)
11441       {
11442          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11443          return RFAILED;
11444       }
11445    }
11446 #endif
11447    if(cellToBeDelete == true)
11448    {
11449       SEARCH_DU_DB(duIdx, duId, duDb);
11450       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11451       if(cellCb->numUe == 0)
11452       {
11453          memset(cellCb, 0, sizeof(CuCellCb));
11454          duDb->numCells--;
11455       }
11456       else
11457          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11458    }
11459    return ROK;
11460 }
11461
11462 /*******************************************************************
11463 *
11464 * @brief storing slice list in CU database
11465 *
11466 * @details
11467 *
11468 *    Function : buildSliceList
11469 *
11470 *    Functionality:
11471 *         - storing slice list in CU database
11472 *
11473 * @params[in] SliceSupportList_t *sliceSupportList
11474 * @return ROK     - success
11475 *         RFAILED - failure
11476 *
11477 * ****************************************************************/
11478 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11479 {
11480    uint8_t sliceListIdx = 0;
11481
11482    if(sliceSupportList)
11483    {
11484       if(sliceSupportList->list.array)
11485       {
11486          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11487          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11488          {
11489             if(sliceSupportList->list.array[sliceListIdx])
11490             {
11491                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11492                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11493                {
11494                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11495                    return RFAILED;
11496                }
11497                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11498                {
11499                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11500                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11501                }
11502                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11503                {
11504                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11505                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11506                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11507                }
11508             }
11509          }
11510       }
11511    }
11512    return ROK;
11513 }
11514
11515 /****************************************************************
11516  * @brief Function to process Srb Setup Mod List
11517  *
11518  * @details
11519  *
11520  *    Function : procSrbSetupModList
11521  *
11522  *    Functionality:
11523  *         - Function to process SRB Setup Mod List
11524  *
11525  * @params[in]
11526  * @return ROK     - success
11527  *         RFAILED - failure
11528  *
11529  * ****************************************************************/
11530 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11531 {
11532    uint8_t arrIdx = 0, srbIdx;
11533    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11534
11535    if(srbSetupList != NULLP)
11536    {
11537       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11538       {
11539          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11540          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11541          {
11542             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11543             {
11544                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11545                {
11546                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11547                   break;
11548                }
11549             }
11550          }
11551
11552       }
11553    }
11554    return ROK;
11555 }
11556
11557
11558 /****************************************************************
11559  * @brief Function to process Drb Setup Mod List
11560  *
11561  * @details
11562  *
11563  *    Function : procDrbSetupModList
11564  *
11565  *    Functionality:
11566  *         - Function to process DRB Setup Mod List
11567  *
11568  * @params[in]
11569  * @return ROK     - success
11570  *         RFAILED - failure
11571  *
11572  * ****************************************************************/
11573 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11574 {
11575    uint8_t arrIdx = 0, drbIdx;
11576    uint32_t teId = 0;
11577    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11578
11579    if(drbSetupList != NULLP)
11580    {
11581       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11582       {
11583          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11584          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11585          {
11586             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11587             {
11588                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11589                {
11590                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11591                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11592                   break;
11593                }
11594             }
11595
11596             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11597             {
11598             /* extracting teId */
11599             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11600             if(teId > 0)
11601             {
11602               if(addDrbTunnels(duId, teId)== ROK)
11603               {
11604                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11605               }
11606             }
11607             else
11608                return RFAILED;
11609             }
11610          }
11611       }
11612    }
11613    return ROK;
11614 }
11615
11616 /*******************************************************************
11617 *
11618 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11619 *
11620 * @details
11621 *
11622 *    Function : procServedCellPlmnList
11623 *
11624 *    Functionality:
11625 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11626 *         SNSSAI list
11627 *
11628 * @params[in] F1AP_PDU_t *f1apMsg
11629 * @return ROK     - success
11630 *         RFAILED - failure
11631 *
11632 * ****************************************************************/
11633 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11634 {
11635    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11636    ProtocolExtensionContainer_4624P3_t **ieExtend;
11637
11638    if(srvPlmn->list.array)
11639    {
11640       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11641       {
11642          if(srvPlmn->list.array[srvPlmnIdx])
11643          {
11644             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11645             if(*ieExtend)
11646             {
11647                if((*ieExtend)->list.array)
11648                {
11649                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11650                   {
11651                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11652                      {
11653                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11654                         {
11655                            case ProtocolIE_ID_id_TAISliceSupportList:
11656                               {
11657                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11658                                           extensionValue.choice.SliceSupportList) != ROK)
11659                                  {
11660                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11661                                     return RFAILED;
11662                                  }
11663                               }
11664                         }
11665                      }
11666                   }
11667                }
11668             }
11669          }
11670       }
11671    }
11672    return ROK;
11673 }
11674
11675 /****************************************************************
11676  * @brief Function to process Ue Context Modification Response
11677  *
11678  * @details
11679  *
11680  *    Function : procUeContextModificationResponse
11681  *
11682  *    Functionality:
11683  *         - Function to process Ue Context Modification Response
11684  *
11685  * @params[in]
11686  * @return ROK     - success
11687  *         RFAILED - failure
11688  *
11689  * ****************************************************************/
11690 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11691 {
11692    uint8_t idx=0, duIdx=0;
11693    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11694    DuDb *duDb = NULLP;
11695    CuUeCb *ueCb = NULLP;
11696    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11697
11698    SEARCH_DU_DB(duIdx, duId, duDb);
11699    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11700
11701    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11702    {
11703       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11704       {
11705           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11706              {
11707                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11708                 break;
11709              }
11710           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11711              {
11712                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11713                 ueCb = &duDb->ueCb[duUeF1apId-1];
11714                 break;
11715              }
11716           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11717              {
11718                 /* Adding Tunnels for successful DRB */
11719                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11720                 break;
11721
11722              }
11723           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11724              {
11725                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11726                 break;
11727              }
11728          case ProtocolIE_ID_id_DUtoCURRCInformation:
11729              {
11730                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11731                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11732                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11733                 {
11734                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11735                    return RFAILED;
11736                 }
11737                 break;
11738              }
11739
11740       }
11741    }
11742
11743    /* If UE is in handover and UE context is not yet created at target DU, then send
11744     * UE context setup request to target DU */
11745    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11746    {
11747       uint8_t ueIdx = 0;
11748       DuDb *tgtDuDb = NULLP;
11749       CuUeCb *ueCbInTgtDu = NULLP;
11750
11751       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11752       if(tgtDuDb)
11753       {
11754          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11755           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11756           * DB */
11757          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11758          {
11759             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11760             {
11761                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11762                break;
11763             }
11764          }
11765
11766          /* If UE context is not found in Target DU DU, send UE context setup
11767           * request */
11768          if(ueCbInTgtDu == NULLP)
11769          {
11770             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
11771             {
11772                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11773                return RFAILED;
11774             }
11775          }
11776       }
11777    }
11778
11779    return ROK;
11780 }
11781
11782 /*******************************************************************
11783 *
11784 * @brief processing of F1 setup request
11785 *
11786 * @details
11787 *
11788 *    Function : procF1SetupReq
11789 *
11790 *    Functionality:
11791 *         - processing of  F1 setup request
11792 *
11793 * @params[in] F1AP_PDU_t *f1apMsg
11794 * @return ROK     - success
11795 *         RFAILED - failure
11796 *
11797 * ****************************************************************/
11798 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11799 {
11800    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11801    uint32_t duId = 0;
11802    uint64_t nrCellId = 0;
11803    DuDb     *duDb = NULLP;
11804    CuCellCb *cellCb = NULLP;
11805    BIT_STRING_t nrcellIdentity;
11806    F1SetupRequest_t *f1SetupReq = NULLP;
11807    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11808    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11809
11810    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11811    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11812    {
11813       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11814       {
11815          case ProtocolIE_ID_id_gNB_DU_ID:
11816            {
11817               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11818               SEARCH_DU_DB(duIdx, duId, duDb);
11819               if(duDb == NULLP)
11820               {
11821                  duDb = &cuCb.duInfo[cuCb.numDu];
11822                  cuCb.numDu++;
11823               }
11824               memset(duDb, 0, sizeof(DuDb));
11825               duDb->duId = duId;
11826               *destDuId = duId;
11827               break;
11828            }
11829          case ProtocolIE_ID_id_gNB_DU_Name:
11830            {
11831               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11832               break;
11833            }
11834          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11835            {
11836                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11837                if(duServedCell->list.array)
11838                {
11839                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11840                   {
11841                      if(duServedCell->list.array[plmnidx])
11842                      {
11843                         switch(duServedCell->list.array[plmnidx]->id)
11844                         {
11845                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11846                            {
11847                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11848                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11849                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11850
11851                               bitStringToInt(&nrcellIdentity, &nrCellId);
11852                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11853                               if(cellCb == NULLP)
11854                               {
11855                                  cellCb = &duDb->cellCb[duDb->numCells];
11856                                  memset(cellCb, 0, sizeof(CuCellCb));
11857                                  cellCb->nrCellId = nrCellId;
11858                                  cellCb->cellStatus = CELL_ACTIVE;
11859                                  duDb->numCells++;
11860                               }
11861                            }
11862                         }
11863                      }
11864                   }
11865                }
11866            }
11867       }
11868    }
11869    if(ret == ROK)
11870    {
11871       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11872    }
11873    else
11874    {
11875        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11876    }
11877 }
11878
11879 /****************************************************************
11880 *
11881 * @brief processing of UE Context Release Complete
11882 *
11883 * @details
11884 *
11885 *    Function : procUeContextReleaseComplete
11886 *
11887 *    Functionality:
11888 *         - processing of UE Context Release Complete
11889 *
11890 * @params[in] F1AP_PDU_t *f1apMsg
11891 * @return ROK     - success
11892 *         RFAILED - failure
11893 *
11894 * ****************************************************************/
11895 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11896 {
11897    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
11898    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11899    DuDb *duDb = NULLP;
11900    CuUeCb *ueCb = NULLP;
11901    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11902
11903    SEARCH_DU_DB(duIdx, duId, duDb);
11904    if(!duDb)
11905    {
11906       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11907       return;
11908    }
11909
11910    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11911    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11912    {
11913       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11914       {
11915          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11916             {
11917                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11918                break;
11919             }
11920          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11921             {
11922                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11923                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11924                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11925                {
11926                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11927                   {
11928                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11929                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11930                      {
11931                         for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11932                         {
11933                            deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
11934                         }
11935                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11936                         ueCb->cellCb->numUe--;
11937                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
11938                         {
11939                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11940                            duDb->numCells--;
11941                         }
11942                         break;
11943                      }
11944                   }
11945                }
11946                memset(ueCb, 0, sizeof(CuUeCb));
11947                duDb->numUe--;
11948                break;
11949             }
11950       }
11951    }
11952 }
11953
11954 /*******************************************************************
11955  *
11956  * @brief Builds the Paging cell list
11957  *
11958  * @details
11959  *
11960  *    Function : BuildPagingCellList
11961  *
11962  *    Functionality: Build the paging cell list
11963  *
11964  * @params[in] PagingCell_list_t  *pagingCelllist,
11965  *
11966  * @return ROK     - success
11967  *         RFAILED - failure
11968  *
11969  * ****************************************************************/
11970 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11971 {
11972    uint8_t cellIdx =0;
11973    PagingCell_ItemIEs_t *pagingCellItemIes;
11974    PagingCell_Item_t *pagingCellItem;
11975
11976    pagingCelllist->list.count = numCells;
11977    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11978    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11979    if(pagingCelllist->list.array == NULLP)
11980    {
11981       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11982       return RFAILED;
11983    }
11984
11985    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11986    {
11987       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11988       if(pagingCelllist->list.array[cellIdx] == NULLP)
11989       {
11990          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11991          return RFAILED;
11992       }
11993    }
11994
11995    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11996    {
11997       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11998       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
11999       pagingCellItemIes->criticality = Criticality_ignore;
12000       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
12001       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12002
12003       /* Fill NrCgi Information */
12004       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
12005    }
12006
12007    return ROK;
12008 }
12009
12010 /*******************************************************************
12011  *
12012  * @brief Deallocation of memory allocated in paging msg
12013  *
12014  * @details
12015  *
12016  *    Function :FreePagingMsg
12017  *
12018  *    Functionality: Deallocation of memory allocated in paging msg
12019  *
12020  * @params[in] F1AP_PDU_t *f1apMsg
12021  *
12022  * @return void
12023  *
12024  * ****************************************************************/
12025 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
12026 {
12027    uint8_t ieIdx, cellIdx;
12028    Paging_t   *paging;
12029    PagingCell_ItemIEs_t *pagingCellItemIes;
12030    PagingCell_Item_t *pagingCellItem;
12031    PagingCell_list_t  *pagingCelllist;
12032
12033    if(f1apMsg)
12034    {
12035       if(f1apMsg->choice.initiatingMessage)
12036       {
12037          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12038          if(paging->protocolIEs.list.array)
12039          {
12040             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
12041             {
12042                if(paging->protocolIEs.list.array[ieIdx])
12043                {
12044                   switch(paging->protocolIEs.list.array[ieIdx]->id)
12045                   {
12046                      case ProtocolIE_ID_id_UEIdentityIndexValue:
12047                      {
12048                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12049                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12050                         break;
12051                      }
12052
12053                      case ProtocolIE_ID_id_PagingIdentity:
12054                      {
12055                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
12056                         {
12057                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12058                            {
12059                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
12060                               {
12061                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12062                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12063                               }
12064                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
12065                                 sizeof(struct CNUEPagingIdentity));
12066                            }
12067                         }
12068                         break;
12069                      }
12070
12071                      case ProtocolIE_ID_id_PagingCell_List:
12072                      {
12073                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
12074                         if(pagingCelllist->list.array)
12075                         {
12076                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12077                            {
12078                               if(pagingCelllist->list.array[cellIdx])
12079                               {
12080                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12081                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
12082                                   {
12083                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12084                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
12085                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
12086                                   }
12087                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12088                               }
12089                            }
12090                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
12091                         }
12092                         break;
12093                      }
12094                   }
12095                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12096                }
12097             }
12098             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12099          }
12100          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12101       }
12102       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12103    }
12104 }
12105 /*******************************************************************
12106  *
12107  * @brief Builds and sends the paging message if UE is in idle mode
12108  *
12109  * @details
12110  *
12111  *    Function : BuildAndSendPagingMsg
12112  *
12113  *    Functionality: Builds and sends the paging message
12114  *
12115  * @params[in] uint32_t duId, uint8_t gsTmsi
12116  *
12117  * @return ROK     - success
12118  *         RFAILED - failure
12119  *
12120  * ****************************************************************/
12121 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
12122 {
12123    bool       memAllocFailed = false;
12124    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
12125    uint16_t   ueId = 0, duIdx = 0;
12126
12127    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
12128     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
12129    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
12130    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
12131
12132    F1AP_PDU_t *f1apMsg = NULLP;
12133    Paging_t   *paging = NULLP;
12134    DuDb       *duDb;
12135    asn_enc_rval_t         encRetVal;
12136
12137    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
12138
12139    SEARCH_DU_DB(duIdx, duId, duDb);
12140    if(duDb == NULLP)
12141    {
12142       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
12143       return ret;
12144    }
12145
12146    while(true)
12147    {
12148       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12149       if(f1apMsg == NULLP)
12150       {
12151          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
12152          break;
12153       }
12154
12155       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
12156
12157       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12158       if(f1apMsg->choice.initiatingMessage == NULLP)
12159       {
12160          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
12161          break;
12162       }
12163       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
12164       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12165       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
12166
12167       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12168
12169       elementCnt = 5;
12170       paging->protocolIEs.list.count = elementCnt;
12171       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
12172
12173       /* Initialize the Paging Message members */
12174       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12175       if(paging->protocolIEs.list.array == NULLP)
12176       {
12177          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
12178          break;
12179       }
12180
12181       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12182       {
12183          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12184          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
12185          {
12186             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12187             memAllocFailed = true;
12188             break;
12189          }
12190       }
12191
12192       if(memAllocFailed == true)
12193       {
12194          break;
12195       }
12196
12197       /* UE Identity Index Value */
12198       ieIdx=0;
12199       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
12200       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12201       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
12202       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
12203       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
12204       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12205             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12206       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
12207       {
12208          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12209          break;
12210       }
12211
12212       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
12213       ueId = gsTmsi % 1024;
12214       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
12215
12216       /* Paging Identity */
12217       ieIdx++;
12218       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
12219       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12220       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
12221       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
12222                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
12223       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
12224             sizeof(struct CNUEPagingIdentity));
12225       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12226       {
12227          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12228          break;
12229       }
12230
12231       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
12232                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
12233
12234       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
12235       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12236             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12237       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
12238       {
12239          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12240          break;
12241       }
12242
12243       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
12244             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
12245
12246       /* Paging Drx */
12247       ieIdx++;
12248       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
12249       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12250       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
12251       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
12252
12253       /* Paging Priority */
12254       ieIdx++;
12255       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
12256       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12257       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
12258       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
12259
12260       /* Paging Cell List */
12261       ieIdx++;
12262       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
12263       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12264       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
12265       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
12266       {
12267          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
12268          break;
12269       }
12270
12271       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12272
12273       /* Encode the UE Context Release Command type as APER */
12274       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12275       encBufSize = 0;
12276       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12277             encBuf);
12278
12279       /* Encode results */
12280       if(encRetVal.encoded == ENCODE_FAIL)
12281       {
12282          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
12283                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12284          break;
12285       }
12286       else
12287       {
12288          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
12289          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12290          {
12291             DU_LOG("%x",encBuf[ieIdx]);
12292          }
12293       }
12294
12295       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
12296       {
12297          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
12298          break;
12299       }
12300
12301       ret = ROK;
12302       break;
12303
12304    }
12305
12306    FreePagingMsg(f1apMsg);
12307    return ret;
12308 }
12309
12310 /*******************************************************************
12311  *
12312  * @brief Handles received F1AP message and sends back response
12313  *
12314  * @details
12315  *
12316  *    Function : F1APMsgHdlr
12317  *
12318  *    Functionality:
12319  *         - Decodes received F1AP control message
12320  *         - Prepares response message, encodes and sends to SCTP
12321  *
12322  * @params[in]
12323  * @return ROK     - success
12324  *         RFAILED - failure
12325  *
12326  * ****************************************************************/
12327 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12328 {
12329    int i;
12330    char *recvBuf;
12331    MsgLen copyCnt;
12332    MsgLen recvBufLen;
12333    F1AP_PDU_t *f1apMsg = NULLP;
12334    asn_dec_rval_t rval; /* Decoder return value */
12335    F1AP_PDU_t f1apasnmsg ;
12336
12337    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12338    ODU_PRINT_MSG(mBuf, 0,0);
12339
12340    /* Copy mBuf into char array to decode it */
12341    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12342    CU_ALLOC(recvBuf, (Size)recvBufLen);
12343
12344    if(recvBuf == NULLP)
12345    {
12346       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12347       return;
12348    }
12349    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12350    {
12351       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12352       return;
12353    }
12354
12355    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12356    for(i=0; i< recvBufLen; i++)
12357    {
12358       DU_LOG("%x",recvBuf[i]);
12359    }
12360
12361    /* Decoding flat buffer into F1AP messsage */
12362    f1apMsg = &f1apasnmsg;
12363    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12364
12365    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12366    CU_FREE(recvBuf, (Size)recvBufLen);
12367
12368    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12369    {
12370       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12371       return;
12372    }
12373    DU_LOG("\n");
12374    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12375
12376    switch(f1apMsg->present)
12377    {
12378       case F1AP_PDU_PR_initiatingMessage:
12379          {
12380             switch(f1apMsg->choice.initiatingMessage->value.present)
12381             {
12382                case InitiatingMessage__value_PR_Reset:
12383                   {
12384                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12385                      BuildAndSendF1ResetAck();
12386                      break;
12387                   }
12388
12389                case InitiatingMessage__value_PR_F1SetupRequest:
12390                   {
12391                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12392                      procF1SetupReq(duId, f1apMsg);
12393                      break;
12394                   }
12395
12396                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12397                   {
12398                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12399                      procGnbDuUpdate(*duId, f1apMsg);
12400                      break;
12401                   }
12402                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12403                   {
12404                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12405                      procInitULRRCMsg(*duId, f1apMsg);
12406                      break;
12407                   }
12408                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12409                   {
12410                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12411                      procUlRrcMsg(*duId, f1apMsg);
12412                      break;
12413                   }
12414
12415                case InitiatingMessage__value_PR_RRCDeliveryReport:
12416                   {
12417                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12418                      break;
12419                   }
12420                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12421                   {
12422                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12423                      procUeContextReleaseReq(*duId, f1apMsg);
12424                      break;
12425                   }
12426                default:
12427                   {
12428                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12429                            f1apMsg->choice.initiatingMessage->value.present);
12430                      return;
12431                   }
12432             }/* End of switch(initiatingMessage) */
12433             break;
12434          }
12435
12436       case F1AP_PDU_PR_successfulOutcome:
12437          {
12438             switch(f1apMsg->choice.successfulOutcome->value.present)
12439             {
12440                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12441                   {
12442                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12443                      break;
12444                   }
12445                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12446                   {
12447                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12448                      procUeContextSetupResponse(*duId, f1apMsg);
12449                      break;
12450                   }
12451                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12452                   {
12453                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12454                      procUeContextModificationResponse(*duId, f1apMsg);
12455                      break;
12456                   }
12457                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12458                   {
12459                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12460                       procUeContextReleaseComplete(*duId, f1apMsg);
12461                       break;
12462                   }
12463                default:
12464                   {
12465                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12466                            f1apMsg->choice.successfulOutcome->value.present);
12467                      return;
12468                   }
12469             }/* End of switch(successfulOutcome) */
12470             break;
12471          }
12472       default:
12473          {
12474             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12475             return;
12476          }
12477    }/* End of switch(f1apMsg->present) */
12478
12479 } /* End of F1APMsgHdlr */
12480
12481 /**********************************************************************
12482   End of file
12483  **********************************************************************/