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