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 CuGlobalCb cuCb;
 152 char encBuf[ENC_BUF_MAX_LEN];
 153 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 154 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 155
 156 /*******************************************************************
 157  *
 158  * @brief Sends F1 msg over SCTP
 159  *
 160  * @details
 161  *
 162  *    Function : SendF1APMsg
 163  *
 164  *    Functionality: Sends F1 msg over SCTP
 165  *
 166  * @params[in] Region region
 167  *             Pool pool
 168  * @return ROK     - success
 169  *         RFAILED - failure
 170  *
 171  * ****************************************************************/
 172 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 173 {
 174    Buffer *mBuf = NULLP;
 175
 176    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 177    {
 178       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 179       {
 180          ODU_PRINT_MSG(mBuf, 0,0);
 181
 182          if(sctpSend(F1_INTERFACE, duId, mBuf) != ROK)
 183          {
 184             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 185             ODU_PUT_MSG_BUF(mBuf);
 186             return RFAILED;
 187          }
 188       }
 189       else
 190       {
 191          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 192          ODU_PUT_MSG_BUF(mBuf);
 193          return RFAILED;
 194       }
 195       ODU_PUT_MSG_BUF(mBuf);
 196    }
 197    else
 198    {
 199       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 200       return RFAILED;
 201    }
 202
 203    return ROK;
 204 } /* SendF1APMsg */
 205
 206 /********************************************************************
 207  *
 208  * @brief Builds and sends the F1SetupResponse
 209  *
 210  * @details
 211  *
 212  *    Function : BuildAndSendF1SetupRsp
 213  *
 214  *    Functionality: Constructs the F1SetupResponse message and sends
 215  *                   it back to the DU through SCTP.
 216  *
 217  * @params[in] void **buf,Buffer to which encoded pattern is written into
 218  * @params[in] int *size,size of buffer
 219  *
 220  * @return ROK     - success
 221  *         RFAILED - failure
 222  *
 223  * ****************************************************************/
 224 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 225 {
 226    uint8_t    idx,ieIdx;
 227    uint8_t    elementCnt,cellCnt;
 228    F1AP_PDU_t         *f1apMsg = NULL;
 229    F1SetupResponse_t  *f1SetupRsp = NULL;
 230    GNB_CU_Name_t      *cuName = NULL;
 231    Cells_to_be_Activated_List_t *cellToActivate;
 232    RRC_Version_t      *rrcVer = NULL;
 233    asn_enc_rval_t     encRetVal;
 234    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 235
 236    /* Allocate the memory for F1SetupRequest_t */
 237    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 238    if(f1apMsg == NULLP)
 239    {
 240       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 241       return RFAILED;
 242    }
 243    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 244
 245    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 246    if(f1apMsg->choice.successfulOutcome == NULLP)
 247    {
 248       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 249       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 250       return RFAILED;
 251    }
 252
 253    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 254    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 255    f1apMsg->choice.successfulOutcome->value.present = \
 256                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 257    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 258
 259    elementCnt = 3;
 260    f1SetupRsp->protocolIEs.list.count = elementCnt;
 261    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 262
 263    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 264          elementCnt * sizeof(F1SetupResponseIEs_t *));
 265    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 266    {
 267       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 268       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 269       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 270       return RFAILED;
 271    }
 272
 273    for(idx=0; idx<elementCnt; idx++)
 274    {
 275       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 276             sizeof(F1SetupResponseIEs_t));
 277       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 278       {
 279          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 280                elementCnt * sizeof(F1SetupResponseIEs_t *));
 281          CU_FREE(f1apMsg->choice.successfulOutcome, \
 282                sizeof(SuccessfulOutcome_t));
 283          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 284          return RFAILED;
 285       }
 286    }
 287
 288    /*TransactionID*/
 289    idx = 0;
 290    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 291    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 292    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 293                                                             F1SetupResponseIEs__value_PR_TransactionID;
 294    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 295                                                                         TRANS_ID;
 296 #if 0
 297    /* CU name IE is of type printableString_t which wireshark is unable to decode.
 298     * However this string is decoded successfully on online decoders.
 299     * Since this is an optional IE and the value received in it are not
 300     * used as of now, eliminating this IE for now to avoid wireshark error.
 301     */
 302    /*CU Name*/
 303    idx++;
 304    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 305    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 306    f1SetupRsp->protocolIEs.list.array[idx]->value.present = F1SetupResponseIEs__value_PR_GNB_CU_Name;
 307    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 308    cuName->size = strlen((char *)cuCb.cuCfgParams.cuName);
 309
 310    CU_ALLOC(cuName->buf, cuName->size);
 311    if(cuName->buf == NULLP)
 312    {
 313       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 314       {
 315          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 316       }
 317       CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 318       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 319       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 320       return RFAILED;
 321    }
 322    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 323 #endif
 324
 325    /*Cells to be activated list*/
 326    idx++;
 327    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 328    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 329    f1SetupRsp->protocolIEs.list.array[idx]->value.present = F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 330    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.Cells_to_be_Activated_List;
 331
 332    cellCnt=1;
 333    cellToActivate->list.count = cellCnt;
 334    cellToActivate->list.size = cellCnt * sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 335    CU_ALLOC(cellToActivate->list.array, 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], sizeof(F1SetupResponseIEs_t));
 342       }
 343       CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 344       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 345       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 346       return RFAILED;
 347    }
 348    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 349    {
 350       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 351       if(cellToActivate->list.array[ieIdx] == NULLP)
 352       {
 353          CU_FREE(cellToActivate->list.array, sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 354          CU_FREE(cuName->buf, sizeof(cuName->size));
 355          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 356          {
 357             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 358          }
 359          CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 360          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 361          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 362          return RFAILED;
 363       }
 364    }
 365    cellToActivate->list.array[0]->id = \
 366                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 367    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 368    cellToActivate->list.array[0]->value.present = \
 369                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 370    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 371       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 372    CU_ALLOC(cellToActivate->list.array[0]->\
 373          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 374          3*sizeof(uint8_t));
 375    if(cellToActivate->list.array[0]->value.choice.\
 376          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 377    {
 378
 379       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 380       {
 381          CU_FREE(cellToActivate->list.array[ieIdx],\
 382                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 383       }
 384
 385       CU_FREE(cellToActivate->list.array,\
 386             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 387       CU_FREE(cuName->buf, sizeof(cuName->size));
 388       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 389       {
 390          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 391                sizeof(F1SetupResponseIEs_t));
 392       }
 393       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 394             elementCnt * sizeof(F1SetupResponseIEs_t *));
 395       CU_FREE(f1apMsg->choice.successfulOutcome, \
 396             sizeof(SuccessfulOutcome_t));
 397       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 398       return RFAILED;
 399    }
 400    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 401          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 402    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 403       nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
 404    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 405          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 406          cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 407          nRCGI.nRCellIdentity.size);
 408    if(cellToActivate->list.array[0]->value.choice.\
 409          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 410    {
 411       CU_FREE(cellToActivate->list.array[0]->\
 412             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 413             3*sizeof(uint8_t));
 414       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 415       {
 416          CU_FREE(cellToActivate->list.array[ieIdx],\
 417                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 418       }
 419
 420       CU_FREE(cellToActivate->list.array,\
 421             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 422       CU_FREE(cuName->buf, sizeof(cuName->size));
 423       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 424       {
 425          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 426                sizeof(F1SetupResponseIEs_t));
 427       }
 428       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 429             elementCnt * sizeof(F1SetupResponseIEs_t *));
 430       CU_FREE(f1apMsg->choice.successfulOutcome, \
 431             sizeof(SuccessfulOutcome_t));
 432       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 433       return RFAILED;
 434    }
 435    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 436
 437    /* RRC Version */
 438    idx++;
 439    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 440                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 441    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 442    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 443                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 444    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 445    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 446
 447    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 448    if(rrcVer->latest_RRC_Version.buf == NULLP)
 449    {
 450       CU_FREE(cuName->buf, sizeof(cuName->size));
 451       for(ieIdx=0; ieIdx<elementCnt; idx++)
 452       {
 453          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 454                sizeof(F1SetupResponseIEs_t));
 455       }
 456       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 457             elementCnt * sizeof(F1SetupResponseIEs_t *));
 458       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 459       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 460       return RFAILED;
 461    }
 462
 463    /* Need to check RRC Version */
 464    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 465    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 466    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 467    if(rrcVer->iE_Extensions == NULLP)
 468    {
 469       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 470       CU_FREE(cuName->buf, sizeof(cuName->size));
 471       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 472       {
 473          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 474                sizeof(F1SetupResponseIEs_t));
 475       }
 476       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 477             elementCnt * sizeof(F1SetupResponseIEs_t *));
 478       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 479       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 480       return RFAILED;
 481    }
 482    rrcVer->iE_Extensions->list.count = 1;
 483    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 484    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 485          sizeof(struct RRC_Version_ExtIEs *));
 486    if(rrcVer->iE_Extensions->list.array == NULLP)
 487    {
 488       CU_FREE(rrcVer->iE_Extensions,\
 489             sizeof(ProtocolExtensionContainer_4624P81_t));
 490       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 491       CU_FREE(cuName->buf, sizeof(cuName->size));
 492       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 493       {
 494          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 495                sizeof(F1SetupResponseIEs_t));
 496       }
 497       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 498             elementCnt * sizeof(F1SetupResponseIEs_t *));
 499       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 500       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 501       return RFAILED;
 502    }
 503    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 504          sizeof(struct RRC_Version_ExtIEs));
 505    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 506    {
 507       CU_FREE(rrcVer->iE_Extensions->list.array,\
 508             sizeof(struct RRC_Version_ExtIEs *));
 509       CU_FREE(rrcVer->iE_Extensions,\
 510             sizeof(ProtocolExtensionContainer_4624P81_t));
 511       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 512       CU_FREE(cuName->buf, sizeof(cuName->size));
 513       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 514       {
 515          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 516                sizeof(F1SetupResponseIEs_t));
 517       }
 518       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 519             elementCnt * sizeof(F1SetupResponseIEs_t *));
 520       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 521       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 522       return RFAILED;
 523    }
 524    rrcVer->iE_Extensions->list.array[0]->id = \
 525                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 526    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 527    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 528                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 529    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 530       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 531    CU_ALLOC(rrcVer->iE_Extensions->list.\
 532          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 533          3*sizeof(uint8_t));
 534    if(rrcVer->iE_Extensions->list.\
 535          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 536    {
 537       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 538             sizeof(struct RRC_Version_ExtIEs));
 539       CU_FREE(rrcVer->iE_Extensions->list.array,\
 540             sizeof(struct RRC_Version_ExtIEs *));
 541       CU_FREE(rrcVer->iE_Extensions,\
 542             sizeof(ProtocolExtensionContainer_4624P81_t));
 543       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 544       CU_FREE(cuName->buf, sizeof(cuName->size));
 545       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 546       {
 547          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 548                sizeof(F1SetupResponseIEs_t));
 549       }
 550       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 551             elementCnt * sizeof(F1SetupResponseIEs_t *));
 552       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 553       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 554       return RFAILED;
 555    }
 556    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 557       Latest_RRC_Version_Enhanced.buf[0] = 0;
 558    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 559       Latest_RRC_Version_Enhanced.buf[1] = 5;
 560    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 561       Latest_RRC_Version_Enhanced.buf[2] = 15;
 562
 563    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 564
 565    /* Encode the F1SetupRequest type as UPER */
 566    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 567    encBufSize = 0;
 568    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 569
 570    /* Clean up */
 571    if(rrcVer)
 572       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 573    if(cuName)
 574       CU_FREE(cuName->buf, cuName->size);
 575    for(idx=0; idx<elementCnt; idx++)
 576    {
 577       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 578    }
 579    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 580    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 581    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 582
 583    /* Check encode results */
 584    if(encRetVal.encoded == ENCODE_FAIL)
 585    {
 586       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 587             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 588       return RFAILED;
 589    }
 590    else
 591    {
 592       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 593       for(int i=0; i< encBufSize; i++)
 594       {
 595          DU_LOG("%x",encBuf[i]);
 596       }
 597    }
 598
 599    /* Sending msg */
 600    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 601    {
 602       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 603       return RFAILED;
 604    }
 605
 606    return ROK;
 607 }/* End of BuildAndSendF1SetupRsp */
 608
 609 /*******************************************************************
 610  *
 611  * @brief Builds and sends the DUUpdateAcknowledge
 612  *
 613  * @details
 614  *
 615  *    Function : BuildAndSendDUUpdateAck
 616  *
 617  *    Functionality: Constructs the DU Update Acknowledge message and sends
 618  *                   it to the DU through SCTP.
 619  *
 620  * @params[in]
 621  *
 622  * @return ROK     - success
 623  *         RFAILED - failure
 624  *
 625  * ****************************************************************/
 626
 627 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 628 {
 629    uint8_t   idx;
 630    uint8_t   elementCnt;
 631    F1AP_PDU_t *f1apMsg = NULL;
 632    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 633    asn_enc_rval_t enRetVal; /* Encoder return value */
 634
 635    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 636
 637    /* Allocate the memory for F1SetupRequest_t */
 638    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 639    if(f1apMsg == NULLP)
 640    {
 641       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 642       return RFAILED;
 643    }
 644
 645    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 646
 647    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 648    if(f1apMsg->choice.successfulOutcome == NULLP)
 649    {
 650       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 651       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 652       return RFAILED;
 653    }
 654
 655    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 656    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 657    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 658    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 659
 660    elementCnt = 1;
 661    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 662    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 663
 664    /* Initialize the F1Setup members */
 665    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 666    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 667    {
 668       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 669       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 670       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 671       return RFAILED;
 672    }
 673
 674    for(idx=0; idx<elementCnt; idx++)
 675    {
 676       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 677       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 678       {
 679          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 680          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 681          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 682          return RFAILED;
 683       }
 684    }
 685
 686    /*TransactionID*/
 687    idx = 0;
 688    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 689    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 690    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 691    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 692    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 693
 694    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 695
 696    /* Encode the F1SetupRequest type as UPER */
 697    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 698    encBufSize = 0;
 699    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 700
 701    /* Clean up */
 702    for(idx=0; idx<elementCnt; idx++)
 703    {
 704       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 705    }
 706    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 707    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 708    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 709
 710    /* Checking encode results */
 711    if(enRetVal.encoded == ENCODE_FAIL)
 712    {
 713       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 714       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 715       return RFAILED;
 716    }
 717    else
 718    {
 719       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 720       for(int i=0; i< encBufSize; i++)
 721       {
 722          DU_LOG("%x",encBuf[i]);
 723       }
 724    }
 725
 726    /* Sending msg */
 727    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 728    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 729    {
 730       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 731       return RFAILED;
 732    }
 733
 734    return ROK;
 735
 736 }/* End of BuildAndSendDUUpdateAck*/
 737
 738 /*******************************************************************
 739 *
 740 * @brief deallocating the memory of  F1reset msg
 741 *
 742 * @details
 743 *
 744 *    Function : FreeF1ResetReq
 745 *
 746 *    Functionality :
 747 *         - freeing memory of F1reset request msg
 748 *
 749 * @params[in]
 750 * @return void
 751 *
 752 *
 753 * ****************************************************************/
 754 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 755 {
 756    uint8_t idx = 0;
 757    Reset_t *f1ResetMsg = NULLP;
 758
 759    if(f1apMsg)
 760    {
 761       if(f1apMsg->choice.initiatingMessage)
 762       {
 763          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 764          if(f1ResetMsg->protocolIEs.list.array)
 765          {
 766             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 767             {
 768                if(f1ResetMsg->protocolIEs.list.array[idx])
 769                {
 770                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 771                }
 772             }
 773             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 774          }
 775          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 776       }
 777       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 778    }
 779 }
 780 /*******************************************************************
 781  *
 782  * @brief build ansld ans send f1reset msg
 783  *
 784  * @details
 785  *
 786  *    Function : BuildAndSendF1ResetReq
 787  *
 788  *    Functionality: build and send f1reset msg
 789  *
 790  * @return ROK     - success
 791  *         RFAILED - failure
 792  *
 793  * ****************************************************************/
 794 uint8_t BuildAndSendF1ResetReq()
 795 {
 796    uint8_t          elementCnt=0;
 797    uint8_t          idx=0;
 798    uint8_t          ret= RFAILED;
 799    Reset_t          *f1ResetMsg = NULLP;
 800    F1AP_PDU_t       *f1apMsg = NULLP;
 801    asn_enc_rval_t   encRetVal;
 802    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 803    do
 804    {
 805       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 806       if(f1apMsg == NULLP)
 807       {
 808          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 809          break;
 810       }
 811       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 812       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 813       if(f1apMsg->choice.initiatingMessage == NULLP)
 814       {
 815          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 816          break;
 817       }
 818       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 819       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 820       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 821
 822       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 823
 824       elementCnt = 3;
 825       f1ResetMsg->protocolIEs.list.count = elementCnt;
 826       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 827
 828       /* Initialize the F1Reset members */
 829       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 830       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 831       {
 832          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 833          break;
 834       }
 835       for(idx=0; idx<elementCnt; idx++)
 836       {
 837          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 838          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 839          {
 840             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 841             break;
 842          }
 843       }
 844
 845       /*TransactionID*/
 846       idx=0;
 847       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 848       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 849       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 850       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 851
 852       /*Cause*/
 853       idx++;
 854       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 855       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 856       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 857       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 858       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 859
 860       /*Reset Type*/
 861       idx++;
 862       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 863       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 864       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 865       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 866       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 867
 868       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 869
 870       /* Encode the F1SetupRequest type as APER */
 871       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 872       encBufSize = 0;
 873       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 874             encBuf);
 875
 876       /* Encode results */
 877       if(encRetVal.encoded == ENCODE_FAIL)
 878       {
 879          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 880                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 881          break;
 882       }
 883       else
 884       {
 885          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 886          for(idx=0; idx< encBufSize; idx++)
 887          {
 888             DU_LOG("%x",encBuf[idx]);
 889          }
 890       }
 891
 892       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 893       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 894       {
 895          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 896          break;
 897       }
 898
 899       ret = ROK;
 900       break;
 901    }while(true);
 902
 903    FreeF1ResetReq(f1apMsg);
 904    return ret;
 905 }
 906
 907 /*******************************************************************
 908  *
 909  * @brief Fills Radio Bearer Config
 910  *
 911  * @details
 912  *
 913  *    Function : fillSrbCfg
 914  *
 915  *    Functionality: Fills Radio Bearer Config
 916  *
 917  * @params[in] SRB_ToAddModList *
 918  *
 919  * @return ROK     - success
 920  *         RFAILED - failure
 921  *
 922  * ****************************************************************/
 923 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 924 {
 925    uint8_t elementCnt = 0;
 926    uint8_t idx, ieId, srbIdx = 0;
 927
 928    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 929    {
 930       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 931          elementCnt++;
 932    }
 933
 934    if(bearerCfg != NULLP)
 935    {
 936       bearerCfg->list.count = elementCnt;
 937       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 938       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 939       if(bearerCfg->list.array != NULLP)
 940       {
 941          for(idx = 0; idx < elementCnt; idx++)
 942          {
 943             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 944             if(bearerCfg->list.array[idx] == NULLP)
 945             {
 946                for(ieId = 0; ieId < idx; ieId++)
 947                {
 948                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 949                }
 950                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 951                return RFAILED;
 952             }
 953          }
 954       }
 955       else
 956       {
 957          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 958          return RFAILED;
 959       }
 960
 961       idx = 0;
 962       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 963       {
 964          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 965             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 966       }
 967    }
 968    return ROK;
 969 }
 970
 971 /*******************************************************************
 972  *
 973  * @brief Fills Master CellGroup Info
 974  *
 975  * @details
 976  *
 977  *    Function : fillMasterCellGroup
 978  *
 979  *    Functionality: Fills Master Cell Group IE
 980  *
 981  * @params[in] RRCSetup_IEs_t *
 982  *
 983  * @return ROK     - success
 984  *         RFAILED - failure
 985  *
 986  * ****************************************************************/
 987
 988 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 989 {
 990    uint8_t ret = ROK;
 991    masterCellGroup->buf = NULLP;
 992    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 993    {
 994       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 995       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 996       if(masterCellGroup->buf != NULLP)
 997       {
 998          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
 999       }
1000       else
1001       {
1002          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
1003          ret = RFAILED;
1004       }
1005    }
1006    else
1007    {
1008       ret =  RFAILED;
1009    }
1010    return ret;
1011 }
1012
1013 /*******************************************************************
1014  *
1015  * @brief Fills RRC setup IE
1016  *
1017  * @details
1018  *
1019  *    Function : fillRRCSetupIE
1020  *
1021  *    Functionality: Fills RRC Setup IE
1022  *
1023  * @params[in] RRCSetup_IEs_t *
1024  *
1025  * @return ROK     - success
1026  *         RFAILED - failure
1027  *
1028  * ****************************************************************/
1029
1030 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1031 {
1032    uint8_t ret = ROK, srbIdx = 0;
1033    if(rrcSetupIE)
1034    {
1035       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1036       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1037       {
1038          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1039       }
1040       if(ret == ROK)
1041       {
1042          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1043       }
1044       else
1045       {
1046          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1047          ret = RFAILED;
1048       }
1049
1050       /* If SRB configuration are filled successfully in RRC Setup, mark these
1051        * configurartion as sent to UE */
1052       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1053       {
1054          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1055             ueCb->srbList[srbIdx].cfgSentToUe = true;
1056       }
1057    }
1058    return ret;
1059 }
1060 /*******************************************************************
1061  *
1062  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1063  *
1064  * @details
1065  *
1066  *    Function : fillDlCcchRrcMsg
1067  *
1068  *    Functionality: Fills DL DCCCH Message required for
1069  *                   DLRRCMessageTransfer
1070  *
1071  * @params[in] RRCContainer_t *rrcContainer
1072  *
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077
1078 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1079 {
1080    uint8_t ret = ROK;
1081    uint16_t idx2;
1082    DL_CCCH_Message_t dl_CCCH_Msg;
1083    asn_enc_rval_t    encRetVal;
1084
1085    if(rrcContainer != NULLP)
1086    {
1087       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1088
1089       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1090       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1091       {
1092          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1093          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1094          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1095          {
1096             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1097             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1098                RRCSetup__criticalExtensions_PR_rrcSetup;
1099
1100             /* Fill RRC Setup IE */
1101             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1102                sizeof(RRCSetup_IEs_t));
1103             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1104             {
1105                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1106
1107                if(ret == ROK)
1108                {
1109                   /* encode DL-CCCH message into RRC Container */
1110                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1111                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1112                   encBufSize = 0;
1113                   encRetVal = uper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1114                   /* Encode results */
1115                   if(encRetVal.encoded == ENCODE_FAIL)
1116                   {
1117                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1118                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1119                      return RFAILED;
1120                   }
1121                   else
1122                   {
1123                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1124                      for(int i = 0; i< encBufSize; i++)
1125                      {
1126                         DU_LOG("%x",encBuf[i]);
1127                      }
1128                      rrcContainer->size = encBufSize;
1129                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1130                      if(rrcContainer->buf != NULLP)
1131                      {
1132                         memset(rrcContainer->buf, 0, encBufSize);
1133                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1134                         {
1135                            rrcContainer->buf[idx2] =    encBuf[idx2];
1136                         }
1137                      }
1138                   }
1139                }
1140                else
1141                {
1142                   ret = RFAILED;
1143                }
1144             }
1145             else
1146             {
1147                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1148                ret = RFAILED;
1149             }
1150          }
1151          else
1152          {
1153             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1154             ret = RFAILED;
1155          }
1156       }
1157       else
1158       {
1159          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1160          ret = RFAILED;
1161       }
1162    }
1163    else
1164    {
1165       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1166       ret = RFAILED;
1167    }
1168 }
1169
1170 /*******************************************************************
1171  *
1172  * @brief Fills QOS flow configuration
1173  *
1174  * @details
1175  *
1176  *    Function : fillQosFlowsToAdd
1177  *
1178  *    Functionality: Fills QOS flow configuration
1179  *
1180  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1181  *
1182  * @return ROK     - success
1183  *         RFAILED - failure
1184  *
1185  * ****************************************************************/
1186 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1187 {
1188    uint8_t idx, ied, elementCnt;
1189
1190    elementCnt = 1;
1191    qosFlow->list.count = elementCnt;
1192    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1193    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1194    if(qosFlow->list.array != NULLP)
1195    {
1196       for(idx = 0; idx < elementCnt; idx++)
1197       {
1198          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1199          if(qosFlow->list.array[idx] == NULLP)
1200          {
1201             for(ied = 0; ied < idx; ied++)
1202             {
1203                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1204             }
1205             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1206             return RFAILED;
1207          }
1208       }
1209    }
1210    idx = 0;
1211    *qosFlow->list.array[idx] = 9;
1212    return ROK;
1213 }
1214
1215 /*******************************************************************
1216  *
1217  * @brief Fills CN Assoc for Drb to Add/Mod List
1218  *
1219  * @details
1220  *
1221  *    Function : fillCnAssoc
1222  *
1223  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1224  *
1225  * @params[in] struct DRB_ToAddMod__cnAssociation *
1226  *
1227  * @return ROK     - success
1228  *         RFAILED - failure
1229  *
1230  * ****************************************************************/
1231
1232 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1233 {
1234    uint8_t ret = ROK;
1235
1236    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1237    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1238    {
1239       cnAssoc->choice.eps_BearerIdentity = 5;
1240    }
1241    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1242    {
1243       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1244       if(cnAssoc->choice.sdap_Config)
1245       {
1246          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1247          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1248          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1249          cnAssoc->choice.sdap_Config->defaultDRB = true;
1250          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1251          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1252          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1253                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1254          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1255          {
1256             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1257          }
1258          else
1259          {
1260             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1261             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1262             ret = RFAILED;
1263          }
1264       }
1265       else
1266       {
1267          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1268          ret = RFAILED;
1269       }
1270    }
1271    return ret;
1272 }
1273
1274 /*******************************************************************
1275  *
1276  * @brief Fills Radio Bearer Config for Drb
1277  *
1278  * @details
1279  *
1280  *    Function : fillDrbCfg
1281  *
1282  *    Functionality: Fills Radio Bearer Config for Drb
1283  *
1284  * @params[in] drbId, DRB_ToAddModList *
1285  *
1286  * @return ROK     - success
1287  *         RFAILED - failure
1288  *
1289  * ****************************************************************/
1290 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1291 {
1292    uint8_t idx, ied, ret, elementCnt;
1293
1294    ret = ROK;
1295    if(drbCfg != NULLP)
1296    {
1297       elementCnt = 1;
1298       drbCfg->list.count = elementCnt;
1299       drbCfg->list.size =\
1300                          elementCnt * sizeof(DRB_ToAddMod_t *);
1301       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1302       if(drbCfg->list.array != NULLP)
1303       {
1304          for(idx = 0; idx < elementCnt; idx++)
1305          {
1306             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1307             if(drbCfg->list.array[idx] == NULLP)
1308             {
1309                for(ied = 0; ied < idx; ied++)
1310                {
1311                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1312                }
1313                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1314                return RFAILED;
1315             }
1316          }
1317       }
1318       else
1319       {
1320          return RFAILED;
1321       }
1322       idx = 0;
1323       /* CN ASSOCIATION */
1324       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1325       if(drbCfg->list.array[idx]->cnAssociation)
1326       {
1327          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1328       }
1329       /* DRB */
1330       drbCfg->list.array[idx]->drb_Identity = drbId;
1331    }
1332    return ret;
1333 }
1334
1335 /*******************************************************************
1336  *
1337  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1338  *
1339  * @details
1340  *
1341  *    Function : fillRrcReconfigIE
1342  *
1343  *    Functionality: Fills RRC Reconfig Message required for
1344  *                   DLRRCMessageTransfer
1345  *
1346  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1347  *
1348  * @return ROK     - success
1349  *         RFAILED - failure
1350  *
1351  * ****************************************************************/
1352
1353 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1354 {
1355    uint8_t ret = ROK;
1356    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1357    if(rrcReconfigMsg->radioBearerConfig)
1358    {
1359       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1360       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1361       {
1362          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1363
1364       }
1365       if(ret == ROK)
1366       {
1367          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1368          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1369          {
1370             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1371             if(ret == RFAILED)
1372             {
1373                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1374                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1375                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1376             }
1377          }
1378       }
1379       else
1380       {
1381          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1382          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1383       }
1384    }
1385
1386    return ret;
1387 }
1388 /*******************************************************************
1389  *
1390  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1391  *
1392  * @details
1393  *
1394  *    Function : fillDlDcchRrcMsg
1395  *
1396  *    Functionality: Fills DL DCCH Message required for
1397  *                   DLRRCMessageTransfer
1398  *
1399  * @params[in] RRCContainer_t *rrcContainer
1400  *
1401  * @return ROK     - success
1402  *         RFAILED - failure
1403  *
1404  * ****************************************************************/
1405
1406 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer, bool updateAllRbCfg)
1407 {
1408    uint8_t ret = ROK;
1409    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1410    DL_DCCH_Message_t dl_DCCH_Msg;
1411    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1412    asn_enc_rval_t        encRetVal;
1413
1414    if(rrcContainer != NULLP)
1415    {
1416       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1417
1418       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1419       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1420       {
1421          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1422          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1423          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1424          {
1425             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1426             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, updateAllRbCfg);
1427             if(ret == ROK)
1428             {
1429                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1430                 * configurartion as sent to UE */
1431                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1432                {
1433                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1434                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1435                }
1436                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1437                {
1438                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1439                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1440                }
1441
1442                /* encode DL-DCCH message into RRC Container */
1443                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1444                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1445                encBufSize = 0;
1446                encRetVal = uper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1447                /* Encode results */
1448                if(encRetVal.encoded == ENCODE_FAIL)
1449                {
1450                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1451                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1452                   return RFAILED;
1453                }
1454                else
1455                {
1456                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1457                   for(int i = 0; i< encBufSize; i++)
1458                   {
1459                      DU_LOG("%x",encBuf[i]);
1460                   }
1461                   rrcContainer->size = encBufSize;
1462                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1463                   if(rrcContainer->buf != NULLP)
1464                   {
1465                      memset(rrcContainer->buf, 0, encBufSize);
1466                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1467                      {
1468                         rrcContainer->buf[idx2] =       encBuf[idx2];
1469                      }
1470                   }
1471                }
1472             }
1473          }
1474          else
1475          {
1476             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1477             ret = RFAILED;
1478          }
1479       }
1480       else
1481       {
1482          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1483          ret = RFAILED;
1484       }
1485    }
1486    else
1487    {
1488       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1489       ret = RFAILED;
1490    }
1491    return ret;
1492 }
1493
1494 /*******************************************************************
1495  *
1496  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1497  *
1498  * @details
1499  *
1500  *    Function : BuildDLRRCContainer
1501  *
1502  *    Functionality: Builds RRC Container IE required for
1503  *                   DLRRCMessageTransfer
1504  *
1505  * @params[in]
1506  *
1507  * @return ROK     - success
1508  *         RFAILED - failure
1509  *
1510  * ****************************************************************/
1511
1512 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1513 {
1514    uint8_t ret, bufLen;
1515
1516    ret =ROK;
1517    if(rrcMsgType == RRC_SETUP)
1518    {
1519       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1520       if(ret == RFAILED)
1521          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1522    }
1523    else if(rrcMsgType == RRC_SETUP_COMPLETE)
1524    {
1525       DU_LOG("\nINFO --> F1AP : Sending NAS Authentication Request");
1526       char authReqBuf[51] = {0x00, ueCb->pdcpSn++, 0x2a, 0x85, 0x4f, 0xc0, 0x0a, 0xc0, 0x40, 0x40, 0x00, 0x04, 0x2f, 0x58, 0x39, 0x12,\
1527                              0x37, 0x15, 0x74, 0x16, 0x4c, 0x8d, 0xd3, 0x95, 0xa6, 0x9e, 0x94, 0x03, 0x24, 0x02, 0x00, 0x6f,\
1528                              0x0b, 0x39, 0x5e, 0xbc, 0xb0, 0x00, 0x1a, 0xb1, 0xc1, 0x3f, 0x84, 0x4f, 0x77, 0xe3, 0x20, 0x00,\
1529                              0x00, 0x00, 0x00};
1530       bufLen = 51;
1531       rrcContainer->size = bufLen;
1532       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1533       if(rrcContainer->buf != NULLP)
1534       {
1535          memset(rrcContainer->buf, 0, bufLen);
1536          memcpy(rrcContainer->buf, authReqBuf, bufLen);
1537       }
1538       else
1539       {
1540          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1541          ret = RFAILED;
1542
1543       }
1544    }
1545    else if(rrcMsgType == NAS_AUTHENTICATION_RSP)
1546    {
1547       DU_LOG("\nINFO --> F1AP : Sending NAS Security mode command");
1548       char secModeBuf[30]={0x00, ueCb->pdcpSn++, 0x2e, 0x82, 0xaf, 0xc0, 0x7d, 0x1c, 0x4e, 0xfc, 0x80, 0x0f, 0xc0,
1549                           0x0b, 0xa0, 0x20, 0x40, 0x9e, 0x0e, 0x1e, 0x0e, 0x1c, 0x26, 0xc0, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00};
1550       bufLen =30;
1551       rrcContainer->size = bufLen;
1552       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1553       if(rrcContainer->buf != NULLP)
1554       {
1555          memset(rrcContainer->buf, 0, bufLen);
1556          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1557       }
1558       else
1559       {
1560          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1561          ret = RFAILED;
1562       }
1563    }
1564    else if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
1565    {
1566       DU_LOG("\nINFO --> F1AP : Sending RRC Security mode command");
1567       char secModeBuf[9]={0x00, ueCb->pdcpSn++, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1568       bufLen =9;
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, secModeBuf, 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 == RRC_SECURITY_MODE_COMPLETE)
1583    {
1584       /*Hardcoded RRC Container from reference logs*/
1585       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1586       char buf[14] ={0x00, ueCb->pdcpSn++, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1587       bufLen =14;
1588       rrcContainer->size = bufLen;
1589       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1590       if(rrcContainer->buf != NULLP)
1591       {
1592          memset(rrcContainer->buf, 0, bufLen);
1593          memcpy(rrcContainer->buf, buf, bufLen);
1594       }
1595       else
1596       {
1597          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1598          ret = RFAILED;
1599       }
1600    }
1601    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1602    {
1603       uint16_t tmpBufIdx = 0, bufIdx = 0;
1604       RRCContainer_t rrcContainerTmp;
1605       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1606       ret = fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, false);
1607       rrcContainer->size = rrcContainerTmp.size + 2;
1608       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1609       if(rrcContainer->buf != NULLP)
1610       {
1611          memset(rrcContainer->buf, 0, rrcContainer->size);
1612          rrcContainer->buf[0] = 0x00;
1613          rrcContainer->buf[1] = ueCb->pdcpSn++; //PDCP SN
1614          for(bufIdx = 2, tmpBufIdx = 0; bufIdx < rrcContainer->size; bufIdx++, tmpBufIdx++)
1615          {
1616             rrcContainer->buf[bufIdx] = rrcContainerTmp.buf[tmpBufIdx];
1617          }
1618       }
1619       if(ret == RFAILED)
1620          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1621    }
1622
1623    return ret;
1624 }
1625
1626 /*******************************************************************
1627  *
1628  * @brief Frees the DLRRCMessageTransfer
1629  *
1630  * @details
1631  *
1632  *    Function : freeDlRrcMessageTransfer
1633  *
1634  *    Functionality: Frees the DLRRCMessageTransfer
1635  *
1636  * @params[in]
1637  *
1638  * @return ROK     - success
1639  *         RFAILED - failure
1640  *
1641  * ****************************************************************/
1642 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1643 {
1644    uint8_t idx=0;
1645    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1646
1647    if(f1apMsg)
1648    {
1649       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1650       if(dlRRCMsg->protocolIEs.list.array)
1651       {
1652          idx = 3;
1653          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1654             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1655          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1656          {
1657             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1658          }
1659          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1660       }
1661       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1662    }
1663 }
1664
1665 /*******************************************************************
1666  *
1667  * @brief Builds and sends the DLRRCMessageTransfer
1668  *
1669  * @details
1670  *
1671  *    Function : BuildAndSendDLRRCMessageTransfer
1672  *
1673  *    Functionality: Constructs the DL RRC Message Transfer and sends
1674  *                   it to the CU through SCTP.
1675  *
1676  * @params[in]
1677  *
1678  * @return ROK     - success
1679  *         RFAILED - failure
1680  *
1681  * ****************************************************************/
1682 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1683 {
1684    uint8_t   elementCnt = 0;
1685    uint8_t  ieId;
1686    uint8_t  idx;
1687    F1AP_PDU_t  *f1apMsg = NULLP;
1688    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1689    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1690
1691    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1692
1693    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1694    if(f1apMsg == NULLP)
1695    {
1696       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1697       return RFAILED;
1698    }
1699
1700    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1701    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1702    if(f1apMsg->choice.initiatingMessage == NULLP)
1703    {
1704       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1705       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1706       return RFAILED;
1707    }
1708
1709    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1710    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1711    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1712    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1713
1714    elementCnt = 4;
1715    dlRRCMsg->protocolIEs.list.count = elementCnt;
1716    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1717
1718    /* Initialize the F1Setup members */
1719    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1720    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1721    {
1722       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1723       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1724       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1725       return RFAILED;
1726    }
1727
1728    for(idx=0; idx<elementCnt; idx++)
1729    {
1730       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1731       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1732       {
1733          for(ieId=0; ieId<idx; ieId++)
1734          {
1735             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1736          }
1737          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1738          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1739          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1740          return RFAILED;
1741       }
1742    }
1743
1744    /* GNB CU UE F1AP ID */
1745    idx = 0;
1746    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1747    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1748    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1749    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1750
1751    /* GNB DU UE F1AP ID */
1752    idx++;
1753    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1754    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1755    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1756    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1757
1758    /* SRBID */
1759    idx++;
1760    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1761    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1762    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1763    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1764
1765    /* RRCContainer */
1766    idx++;
1767    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1768    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1769    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1770    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1771
1772    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1773
1774    /* Encode the F1SetupRequest type as APER */
1775    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1776    encBufSize = 0;
1777    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1778          encBuf);
1779    /* Encode results */
1780    if(encRetVal.encoded == ENCODE_FAIL)
1781    {
1782       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1783             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1784       return RFAILED;
1785    }
1786    else
1787    {
1788       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1789       for(int i=0; i< encBufSize; i++)
1790       {
1791          DU_LOG("%x",encBuf[i]);
1792       }
1793    }
1794
1795    /* Sending  msg  */
1796    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1797    {
1798       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1799       return RFAILED;
1800    }
1801    freeDlRrcMessageTransfer(f1apMsg);
1802    return ROK;
1803 }/* End of BuildAndSendDLRRCMessageTransfer */
1804
1805 /*******************************************************************
1806  *
1807  * @brief Function to set the Dl RRC Msg Type
1808  *
1809  * @details
1810  *
1811  *    Function : setDlRRCMsgType
1812  *
1813  *    Functionality: Constructs the UE Setup Response and sends
1814  *                   it to the DU through SCTP.
1815  *
1816  * @params[in]
1817  *
1818  * @return ROK     - success
1819  *         RFAILED - failure
1820  *
1821  * ****************************************************************/
1822
1823 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1824 {
1825    uint8_t rrcMsgType = 0;
1826    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1827    {
1828       case RRC_SETUP:
1829          rrcMsgType = RRC_SETUP;
1830          break;
1831       case RRC_SETUP_COMPLETE:
1832          rrcMsgType = RRC_SETUP_COMPLETE;
1833          break;
1834       case NAS_AUTHENTICATION_RSP:
1835          rrcMsgType = NAS_AUTHENTICATION_RSP;
1836          break;
1837       case NAS_SECURITY_MODE_COMPLETE:
1838          rrcMsgType = NAS_SECURITY_MODE_COMPLETE;
1839          break;
1840       case RRC_SECURITY_MODE_COMPLETE:
1841          rrcMsgType = RRC_SECURITY_MODE_COMPLETE;
1842          break;
1843       case REGISTRATION_COMPLETE:
1844          rrcMsgType = REGISTRATION_COMPLETE;
1845          break;
1846       case UE_CONTEXT_SETUP_RSP:
1847          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1848          break;
1849       case RRC_RECONFIG_COMPLETE:
1850          rrcMsgType = RRC_RECONFIG_COMPLETE;
1851          break;
1852       default:
1853          break;
1854    }
1855    return rrcMsgType;
1856 }
1857
1858 #ifdef NR_DRX
1859 /*******************************************************************
1860  *
1861  * @brief fill long cycle offset value of drx
1862  *
1863  * @details
1864  *
1865  *    Function : fillLongCycleOffsetValue
1866  *
1867  *    Functionality: fill long cycle offset value of drx
1868  *
1869  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
1870  * struct DRX_ConfigRrc__drx_LongCycleStartOffset recvedLongCycleOffsetVal
1871  *
1872  * @return ROK     - success
1873  *         RFAILED - failure
1874  *
1875  * ****************************************************************/
1876 void fillLongCycleOffsetValue(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset *recvedLongCycleOffsetVal)
1877 {
1878
1879    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = recvedLongCycleOffsetVal->present;
1880    switch(recvedLongCycleOffsetVal->present)
1881    {
1882       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
1883          {
1884             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10;
1885             break;
1886          }
1887       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
1888          {
1889             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms20;
1890             break;
1891          }
1892       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
1893          {
1894             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms32;
1895             break;
1896          }
1897       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
1898          {
1899             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms40;
1900             break;
1901          }
1902       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
1903          {
1904             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms60;
1905             break;
1906          }
1907       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
1908          {
1909             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms64;
1910             break;
1911          }
1912       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
1913          {
1914             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms70;
1915             break;
1916          }
1917       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
1918          {
1919             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms80;
1920             break;
1921          }
1922       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
1923          {
1924             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms128;
1925             break;
1926          }
1927       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
1928          {
1929             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms160;
1930             break;
1931          }
1932       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
1933          {
1934             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms256;
1935             break;
1936          }
1937       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
1938          {
1939             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms320;
1940             break;
1941          }
1942       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
1943          {
1944             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms512;
1945             break;
1946          }
1947       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
1948          {
1949             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms640;
1950             break;
1951          }
1952       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
1953          {
1954             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1024;
1955             break;
1956          }
1957       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
1958          {
1959             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1280;
1960             break;
1961          }
1962       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
1963          {
1964             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2048;
1965             break;
1966          }
1967       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
1968          {
1969             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2560;
1970             break;
1971          }
1972       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
1973          {
1974             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms5120;
1975             break;
1976          }
1977       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
1978          {
1979             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10240;
1980             break;
1981          }
1982       default :
1983          break;
1984    }
1985 }
1986
1987 /*******************************************************************
1988  *
1989  * @brief Extract configuration from DRX_ConfigRrc
1990  *    and store the drx configuration in UeCb
1991  *
1992  * @details
1993  *
1994  *    Function : storeDrxCfgInUeCb
1995  *
1996  *    Functionality: Store drx configuration in UeCb
1997  *
1998  * @params[in] (struct DRX_ConfigRrc *setup, DrxCfg *drxCfg)
1999  *
2000  * @return void
2001  * ****************************************************************/
2002 void storeDrxCfgInUeCb(struct DRX_ConfigRrc *drxSetup, DrxCfg *drxCfg)
2003 {
2004    switch(drxSetup->drx_onDurationTimer.present)
2005    {
2006       case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
2007          break;
2008       case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
2009          {
2010             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
2011             drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=drxSetup->drx_onDurationTimer.choice.milliSeconds;
2012             break;
2013          }
2014       case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
2015          {
2016             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
2017             drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = drxSetup->drx_onDurationTimer.choice.subMilliSeconds;
2018             break;
2019          }
2020    }
2021    fillLongCycleOffsetValue(&drxCfg->drxLongCycleStartOffset, &drxSetup->drx_LongCycleStartOffset);
2022    drxCfg->drxInactivityTimer = drxSetup->drx_InactivityTimer;
2023    drxCfg->drxHarqRttTimerDl = drxSetup->drx_HARQ_RTT_TimerDL;
2024    drxCfg->drxHarqRttTimerUl = drxSetup->drx_HARQ_RTT_TimerUL;
2025    drxCfg->drxRetransmissionTimerDl = drxSetup->drx_RetransmissionTimerDL;
2026    drxCfg->drxRetransmissionTimerUl = drxSetup->drx_RetransmissionTimerUL;
2027    drxCfg->drxSlotOffset = drxSetup->drx_SlotOffset;
2028    if(drxSetup->shortDRX)
2029    {
2030       drxCfg->shortDrxPres=true;
2031       drxCfg->shortDrx.drxShortCycle = drxSetup->shortDRX->drx_ShortCycle;
2032       drxCfg->shortDrx.drxShortCycleTimer = drxSetup->shortDRX->drx_ShortCycleTimer;
2033    }
2034    else
2035       drxCfg->shortDrxPres=false;
2036 }
2037 #endif
2038
2039 /*******************************************************************
2040  *
2041  * @brief Extract configuration from CellGroupConfig
2042  *
2043  * @details
2044  *
2045  *    Function : extractCellGroupConfig
2046  *
2047  *    Functionality: Extract configuration from CellGroupConfig
2048  *        and store in local database
2049  *
2050  * @params[in] UE control block
2051  *             Cell Group Config
2052  *
2053  * @return ROK     - success
2054  *         RFAILED - failure
2055  *
2056  * ****************************************************************/
2057 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
2058 {
2059    uint8_t rbIdx, srbIdx, drbIdx;
2060    bool    srbFound, drbFound;
2061    SrbInfo *srbCfgDb = NULLP;
2062    DrbInfo *drbCfgDb = NULLP;
2063    RlcLcCfg *rlcLcCfgDb = NULLP;
2064    MacLcCfg *macLcCfgDb = NULLP;
2065    RLC_BearerConfig_t *rlcCfg = NULLP;
2066    RLC_Config_t *rlcLcCfg = NULLP;
2067    LogicalChannelConfig_t *macLcCfg = NULLP;
2068 #ifdef NR_DRX
2069    DrxCfg    drxCfg;
2070 #endif
2071
2072    if(ueCb == NULLP)
2073    {
2074       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
2075       return RFAILED;
2076    }
2077
2078    if(cellGrpCfg == NULLP)
2079    {
2080       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
2081       return RFAILED;
2082    }
2083
2084 #ifdef NR_DRX
2085    if(cellGrpCfg->mac_CellGroupConfig)
2086    {
2087       if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc)
2088       {
2089          switch(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->present)
2090          {
2091             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
2092                break;
2093
2094             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
2095             {
2096                if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup)
2097                {
2098                   ueCb->drxCfgPresent = true;
2099                   storeDrxCfgInUeCb(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup, &ueCb->drxCfg);
2100                }
2101                break;
2102             }
2103
2104             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
2105                break;
2106          }
2107       }
2108    }
2109 #endif
2110
2111    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
2112    {
2113       srbFound = false;
2114       drbFound = false;
2115
2116       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
2117
2118       /* Update SRB configuration in local DB */
2119       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
2120       {
2121          /* Search if SRB entry is already present in DB */
2122          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
2123          {
2124             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
2125             {
2126               srbCfgDb = &ueCb->srbList[srbIdx];
2127               srbFound = true;
2128               break;
2129             }
2130          }
2131
2132          /* If not, add SRB to UE CB's SRB list */
2133          if(!srbFound)
2134          {
2135             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
2136             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
2137             ueCb->numSrb++;
2138          }
2139
2140          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2141          srbCfgDb->cfgSentToUe = false;
2142          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
2143          macLcCfgDb = &srbCfgDb->macLcCfg;
2144       }
2145
2146       /* Update DRB configuration in local DB */
2147       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
2148       {
2149          /* Search if DRB entry is already present in DB */
2150          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
2151          {
2152             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
2153             {
2154               drbCfgDb = &ueCb->drbList[drbIdx];
2155               drbFound = true;
2156               break;
2157             }
2158          }
2159
2160          /* If not, add DRB to UE CB's SRB list */
2161          if(!drbFound)
2162          {
2163             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
2164             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
2165             ueCb->numDrb++;
2166          }
2167
2168          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2169          drbCfgDb->cfgSentToUe = false;
2170          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
2171          macLcCfgDb = &drbCfgDb->macLcCfg;
2172       }
2173
2174
2175       /* Update RLC configuration for this RB */
2176       rlcLcCfg = rlcCfg->rlc_Config;
2177       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
2178       switch(rlcLcCfgDb->rlcMode)
2179       {
2180          case RLC_Config_PR_am:
2181             {
2182                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
2183                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
2184                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
2185                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
2186                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
2187
2188                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
2189                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
2190                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
2191                break;
2192             }
2193
2194          case RLC_Config_PR_um_Bi_Directional:
2195             {
2196                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
2197
2198                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
2199                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
2200                break;
2201             }
2202       }
2203
2204       /* Update MAC configuration for this LC */
2205       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
2206       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
2207       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
2208       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
2209       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
2210       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
2211    }
2212    return ROK;
2213 }
2214
2215 /*******************************************************************
2216  *
2217  * @brief Function to decode DU to CU RRC container
2218  *
2219  * @details
2220  *
2221  *    Function : extractDuToCuRrcCont
2222  *
2223  *    Functionality: Function to decode DU to CU RRC container
2224  *
2225  * @params[in] UE Cb
2226  *             RRC conatiner octect string to be decoded
2227  *
2228  * @return ROK     - success
2229  *         RFAILED - failure
2230  *
2231  * ****************************************************************/
2232 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
2233 {
2234    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
2235    asn_dec_rval_t rval; /* Decoder return value */
2236
2237    /* Copy the received container to UeCb */
2238    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
2239
2240    /* Decoding DU to CU RRC container octet string to cell group config */
2241    cellGrpCfgMsg = &cellGrpCfg;
2242    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
2243
2244    rval = uper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
2245
2246    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2247    {
2248       DU_LOG("\nERROR  -->  F1AP : ASN decode failed in extractDuToCuRrcCont");
2249       return RFAILED;
2250    }
2251    printf("\n");
2252    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
2253
2254    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
2255    {
2256       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
2257       return RFAILED;
2258    }
2259
2260    return ROK;
2261 }
2262
2263 /*******************************************************************
2264  *
2265  * @brief Function to build Initial UL RRC Message
2266  *
2267  * @details
2268  *
2269  *    Function : procInitULRRCMsg
2270  *
2271  *    Functionality: Function to build Initial UL RRC Message
2272  *
2273  * @params[in]
2274  *
2275  * @return ROK     - success
2276  *         RFAILED - failure
2277  *
2278  * ****************************************************************/
2279
2280 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2281 {
2282    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2283    uint8_t ret =ROK;
2284    uint16_t cellIdx=0, nrCellId = 0;
2285    uint32_t crnti;
2286    DuDb     *duDb;
2287    CuCellCb *cellCb;
2288    CuUeCb   *ueCb;
2289    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2290
2291    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2292
2293    SEARCH_DU_DB(duIdx, duId, duDb);
2294    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2295
2296    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2297    {
2298       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2299       {
2300          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2301             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2302             break;
2303
2304          case ProtocolIE_ID_id_NRCGI:
2305             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2306             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2307             if(cellCb == NULLP)
2308                return RFAILED;
2309             break;
2310
2311          case ProtocolIE_ID_id_C_RNTI:
2312             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2313             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2314             {
2315                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2316                memset(ueCb, 0, sizeof(CuUeCb));
2317                ueCb->cellCb = cellCb;
2318                ueCb->crnti = crnti;
2319                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2320                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2321                ueCb->state = UE_ATTACH_IN_PROGRESS;
2322                (duDb->numUe)++;
2323
2324                cellCb->ueCb[cellCb->numUe] = ueCb;
2325                cellCb->numUe++;
2326             }
2327             break;
2328
2329          case ProtocolIE_ID_id_RRCContainer:
2330             break;
2331
2332          case ProtocolIE_ID_id_DUtoCURRCContainer:
2333             {
2334                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2335                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2336                {
2337                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2338                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2339                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2340                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2341                   {
2342                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2343                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2344                         ueCb->f1apMsgDb.duToCuContainer.size);
2345                   }
2346                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2347                   {
2348                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2349                      ret = RFAILED;
2350                   }
2351                }
2352                else
2353                {
2354                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2355                   ret = RFAILED;
2356                }
2357                break;
2358             }
2359
2360          default:
2361             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2362             break;
2363       }
2364       if(ret == RFAILED)
2365          break;
2366    }
2367
2368    if(ret == ROK)
2369    {
2370       ueCb->f1apMsgDb.dlRrcMsgCount++;
2371       rrcMsgType = setDlRRCMsgType(ueCb);
2372       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2373    }
2374    return ret;
2375 }
2376
2377 /*******************************************************************
2378  *
2379  * @brief Builds Nrcgi
2380  *
2381  * @details
2382  *
2383  *    Function : BuildNrcgi
2384  *
2385  *    Functionality: Building the PLMN ID and NR Cell id
2386  *
2387  * @params[in] NRCGI_t *nrcgi
2388  * @return ROK     - success
2389  *         RFAILED - failure
2390  *
2391  * ****************************************************************/
2392 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2393 {
2394    uint8_t ret;
2395    uint8_t unused_bits = 4;
2396    uint8_t byteSize = 5;
2397
2398    /* Allocate Buffer Memory */
2399    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2400    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2401    if(nrcgi->pLMN_Identity.buf == NULLP)
2402    {
2403       return RFAILED;
2404    }
2405    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2406
2407    if(ret != ROK)
2408    {
2409       return RFAILED;
2410    }
2411    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2412    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2413    if(nrcgi->nRCellIdentity.buf == NULLP)
2414    {
2415       return RFAILED;
2416    }
2417    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2418
2419    return ROK;
2420 }
2421 /*******************************************************************
2422  *
2423  * @brief Builds Special cell list for UE Setup Request
2424  *
2425  * @details
2426  *
2427  *    Function : BuildSplCellList
2428  *
2429  *    Functionality: Constructs the Special Cell list for UESetReq
2430  *
2431  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2432  *
2433  * @return ROK     - success
2434  *         RFAILED - failure
2435  *
2436  * ****************************************************************/
2437 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2438 {
2439    uint8_t  cellCnt;
2440    uint8_t  idx;
2441    uint8_t  ret;
2442    cellCnt = 1;
2443    spCellLst->list.count = cellCnt;
2444    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2445    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2446    if(spCellLst->list.array == NULLP)
2447    {
2448       return RFAILED;
2449    }
2450    for(idx=0; idx<cellCnt; idx++)
2451    {
2452       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2453       if(spCellLst->list.array[idx] == NULLP)
2454       {
2455          return RFAILED;
2456       }
2457    }
2458    idx = 0;
2459    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2460    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2461    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2462
2463    /* Special Cell ID -NRCGI */
2464    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2465    if(ret != ROK)
2466    {
2467       return RFAILED;
2468    }
2469    /*Special Cell Index*/
2470    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2471    return ROK;
2472 }/* End of BuildSplCellList*/
2473
2474 /*******************************************************************
2475  *
2476  * @brief Builds SRBS to be setup
2477  *
2478  * @details
2479  *
2480  *    Function : BuildSRBSetup
2481  *
2482  *    Functionality: Constructs the SRB's for UESetReq
2483  *
2484  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2485  *
2486  * @return ROK     - success
2487  *         RFAILED - failure
2488  *
2489  * ****************************************************************/
2490 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2491 {
2492    uint8_t idx;
2493    uint8_t srbCnt;
2494
2495    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2496       srbCnt = ueCb->numSrb;
2497    else
2498       srbCnt = 1;
2499    srbSet->list.count = srbCnt;
2500    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2501    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2502    if(srbSet->list.array == NULLP)
2503    {
2504       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2505       return RFAILED;
2506    }
2507
2508    for(idx=0; idx<srbCnt; idx++)
2509    {
2510       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2511       if(srbSet->list.array[idx] == NULLP)
2512       {
2513          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2514          return RFAILED;
2515       }
2516    }
2517
2518    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2519    {
2520       idx = 0;
2521       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2522       srbSet->list.array[idx]->criticality = Criticality_ignore;
2523       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2524       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2525       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2526       ueCb->numSrb++;
2527    }
2528    else
2529    {
2530       for(idx=0; idx<srbCnt; idx++)
2531       {
2532          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2533          srbSet->list.array[idx]->criticality = Criticality_ignore;
2534          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2535          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2536       }
2537    }
2538    return ROK;
2539 }/* End of BuildSRBSetup*/
2540
2541 /*******************************************************************
2542  *
2543  * @brief Builds QOS Info for DRB Setum Item
2544  *
2545  * @details
2546  *
2547  *    Function : BuildQOSInfo
2548  *
2549  *    Functionality: Constructs the QOS Info for DRB Setup Item
2550  *
2551  * @params[in] QoSInformation_t *qosinfo
2552  *             int16_t pduSessionID
2553  *
2554  * @return ROK     - success
2555  *         RFAILED - failure
2556  *
2557  * ****************************************************************/
2558 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2559 {
2560    uint8_t elementCnt = 0, qosCntIdx = 0;
2561    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2562
2563    /* NonDynamic5QIDescriptor */
2564    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2565    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2566    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2567    {
2568       return RFAILED;
2569    }
2570
2571    if(hoInProgress == Inter_DU_HO)
2572       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2573    else if(hoInProgress == false || hoInProgress == Xn_Based_Inter_CU_HO)
2574    {
2575       /*FiveQI*/
2576       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2577          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2578       else
2579          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2580
2581       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2582    }
2583
2584    if(!hoInProgress)
2585    {
2586       /*AveragingWindow*/
2587       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2588       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2589       {
2590          return RFAILED;
2591       }
2592       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2593       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2594
2595       /*MaxDataBurstVolume*/
2596       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2597       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2598       {
2599          return RFAILED;
2600       }
2601       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2602       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2603    }
2604
2605    /*nRGRAN Allocation Retention Priority*/
2606    if(hoInProgress)
2607    {
2608       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2609       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2610       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2611    }
2612    else if((hoInProgress == false) || (hoInProgress == Xn_Based_Inter_CU_HO))
2613    {
2614       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2615       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2616       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2617
2618       qosInfo->priorityLevel = PriorityLevel_lowest;
2619       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2620       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2621    }
2622
2623    /* PDU session ID */
2624    if(!hoInProgress)
2625    {
2626       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2627       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2628       {
2629          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2630          return ROK;
2631       }
2632
2633       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2634       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2635
2636       if(qosIeExt)
2637       {
2638          elementCnt = NUM_QOS_EXT;
2639          qosIeExt->list.count = elementCnt;
2640          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2641
2642          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2643          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2644
2645          if(qosIeExt->list.array == NULLP)
2646          {
2647             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2648             return  RFAILED;
2649          }
2650
2651          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2652          {
2653             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2654             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2655             {
2656                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2657                return  RFAILED;
2658             }
2659             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2660             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2661             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2662             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2663             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2664                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2665             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2666             qosInfo->pduSessionId = pduSessionID;
2667          }
2668       }
2669       else
2670       {
2671          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2672          return RFAILED;
2673       }
2674    }
2675    return ROK;
2676 }/*End of BuildQOSInfo*/
2677
2678 /*******************************************************************
2679  *
2680  * @brief Builds SNSSAI
2681  *
2682  * @details
2683  *
2684  *    Function : BuildSNSSAI
2685  *
2686  *    Functionality: Constructs the SNSSAI For DRB list
2687  *
2688  * @params[in] SNSSAI_t *snssai
2689  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2690  *
2691  * @return ROK     - success
2692  *         RFAILED - failure
2693  *
2694  * ****************************************************************/
2695 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2696 {
2697    /*SNSSAI*/
2698    /* In case of non-HO UE context creation and Xn Based HO, DRB's SNSSAI
2699     * configuration is not known beforehand. In these 2 case, the following
2700     * condition will hit */
2701    if(!hoInProgress || (hoInProgress == Xn_Based_Inter_CU_HO))
2702       drbInfo->snssai = snssaiToCopy;
2703
2704    /*ssT*/
2705    snssai->sST.size = sizeof(uint8_t);
2706    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2707    if(snssai->sST.buf == NULLP)
2708    {
2709       return RFAILED;
2710    }
2711    memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2712
2713    /*sD*/
2714    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2715    if(snssai->sD == NULLP)
2716    {
2717       return RFAILED;
2718    }
2719    snssai->sD->size = 3 * sizeof(uint8_t);
2720    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2721    if(snssai->sD->buf == NULLP)
2722    {
2723       return RFAILED;
2724    }
2725    memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2726
2727    return ROK;
2728 }/*End of BuildSNSSAI*/
2729
2730 /*******************************************************************
2731  *
2732  * @brief Builds the flow map.
2733  *
2734  * @details
2735  *
2736  *    Function : BuildFlowsMap
2737  *
2738  *    Functionality: Constructs the flowmap For DRB list
2739  *
2740  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2741  *
2742  * @return ROK     - success
2743  *         RFAILED - failure
2744  *
2745  * ****************************************************************/
2746 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2747 {
2748    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2749    FlowsMapped *qosFlow;
2750
2751    /* In case of non-HO UE context creation and Xn Based HO, DRB's SNSSAI
2752     * configuration is not known beforehand. In these 2 case, the following
2753     * condition will hit */
2754    if(!hoInProgress || (hoInProgress == Xn_Based_Inter_CU_HO))
2755       flowCnt = 1;
2756    else
2757       flowCnt = drbInfo->numFlowMap;
2758
2759    flowMap->list.count = flowCnt;
2760    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2761    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2762    if(flowMap->list.array == NULLP)
2763    {
2764       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2765       return RFAILED;
2766    }
2767    for(idx=0; idx<flowCnt; idx++)
2768    {
2769       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2770       if(flowMap->list.array[idx] == NULLP)
2771       {
2772          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2773          return RFAILED;
2774       }
2775
2776       if(!hoInProgress || (hoInProgress == Xn_Based_Inter_CU_HO))
2777       {
2778          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2779          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2780          {
2781             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2782             {
2783                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2784                {
2785                   qosFlow = &drbInfo->flowMapList[flowIdx];
2786                   break;
2787                }
2788             }
2789          }
2790          else
2791          {
2792             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2793             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2794          }
2795       }
2796       else
2797       {
2798          qosFlow = &drbInfo->flowMapList[idx];
2799          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2800       }
2801
2802       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2803             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2804       if(ret != ROK)
2805       {
2806          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2807          return RFAILED;
2808       }
2809
2810       if(((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item)) || (hoInProgress == Xn_Based_Inter_CU_HO))
2811          drbInfo->numFlowMap++;
2812    }
2813    return ROK;
2814 }/*End of BuildFlowsMap*/
2815
2816 /*******************************************************************
2817  *
2818  * @brief Builds the Uplink Tunnel Info
2819  *
2820  * @details
2821  *
2822  *    Function : BuildULTnlInfo
2823  *
2824  *    Functionality: Constructs the UL TnlInfo For DRB list
2825  *
2826  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2827  *
2828  * @return ROK     - success
2829  *         RFAILED - failure
2830  *
2831  * ****************************************************************/
2832 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2833 {
2834    uint8_t idx;
2835    uint8_t ulCnt;
2836
2837    ulCnt = 1;
2838    ulInfo->list.count = ulCnt;
2839    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2840    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2841    if(ulInfo->list.array == NULLP)
2842    {
2843       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2844       return RFAILED;
2845    }
2846    for(idx=0; idx<ulCnt; idx++)
2847    {
2848       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2849       if(ulInfo->list.array[idx] == NULLP)
2850       {
2851          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2852               return RFAILED;
2853       }
2854    }
2855    idx = 0;
2856    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2857    /*GTP TUNNEL*/
2858    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2859    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2860    {
2861       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2862       return RFAILED;
2863    }
2864    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2865    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2866       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2867    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2868    {
2869       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2870       return RFAILED;
2871    }
2872
2873    if((!hoInProgress) || (hoInProgress == Xn_Based_Inter_CU_HO))
2874    {
2875       /* NOTE: Below IP address must be changed if running on different IP configuration */
2876       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2877       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2878       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2879       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2880       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2881
2882       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2883       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2884       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2885       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2886    }
2887    else
2888    {
2889       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2890       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2891       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2892       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2893       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2894    }
2895
2896    /*GTP TEID*/
2897    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2898    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2899       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2900    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2901    {
2902       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2903       return RFAILED;
2904    }
2905
2906    if((!hoInProgress) || (hoInProgress == Xn_Based_Inter_CU_HO))
2907    {
2908       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2909       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2910       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2911       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2912
2913       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2914       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2915       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2916       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2917    }
2918    else
2919    {
2920       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2921       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2922       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2923       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2924    }
2925    return ROK;
2926 }/*End of BuildULTnlInfo*/
2927
2928 /*******************************************************************
2929  *
2930  * @brief Builds DRBS to be setup
2931  *
2932  * @details
2933  *
2934  *    Function : BuildDRBSetup
2935  *
2936  *    Functionality: Constructs the DRB's for UESetReq
2937  *
2938  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2939  *
2940  * @return ROK     - success
2941  *         RFAILED - failure
2942  *
2943  * ****************************************************************/
2944 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2945 {
2946    uint16_t snssaiIdx=0;
2947    uint8_t idx = 0, extIeIdx = 0;
2948    uint8_t elementCnt = 0, drbCnt = 0;
2949    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2950    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2951    DRBs_ToBeSetup_Item_t *drbSetItem;
2952    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2953    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2954
2955    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2956       drbCnt = ueCb->numDrb;
2957    else
2958       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2959    drbSet->list.count = drbCnt;
2960
2961    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2962    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2963    if(drbSet->list.array == NULLP)
2964    {
2965       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2966       return RFAILED;
2967    }
2968
2969    for(idx=0; idx<drbCnt; idx++)
2970    {
2971       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2972       if(drbSet->list.array[idx] == NULLP)
2973       {
2974          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2975          return RFAILED;
2976       }
2977
2978       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2979       drbSet->list.array[idx]->criticality = Criticality_ignore;
2980       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2981       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2982       /*dRBID*/
2983       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2984       {
2985          drbSetItem->dRBID = idx + 1;
2986          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2987       }
2988       else
2989          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2990
2991       /*qoSInformation*/
2992       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2993       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2994       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2995       {
2996          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2997          return RFAILED;
2998       }
2999       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
3000       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
3001       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
3002       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3003          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
3004                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
3005       else
3006          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
3007                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, ueCb->hoInfo.HOType);
3008       if(BuildQOSInforet != ROK)
3009       {
3010          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
3011          return RFAILED;
3012       }
3013
3014       /*SNSSAI*/
3015       snssaiIdx = (idx% cuCb.numSnssaiSupported);
3016       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3017          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
3018                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
3019       else
3020          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
3021                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], ueCb->hoInfo.HOType);
3022       if(BuildSNSSAIret != ROK)
3023       {
3024          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
3025          return RFAILED;
3026       }
3027
3028       /*Flows mapped to DRB List*/
3029       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3030          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
3031                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
3032       else
3033          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
3034                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, ueCb->hoInfo.HOType);
3035       if(BuildFlowsMapret != ROK)
3036       {
3037          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
3038          return RFAILED;
3039       }
3040
3041       /*ULUPTNLInformation To Be Setup List*/
3042       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3043          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3044                FALSE);
3045       else
3046          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3047                ueCb->hoInfo.HOType);
3048       if(BuildULTnlInforet != ROK)
3049       {
3050          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
3051          return RFAILED;
3052       }
3053
3054       /*RLCMode*/
3055       if((ueCb->state != UE_HANDOVER_IN_PROGRESS) || (ueCb->hoInfo.HOType == Xn_Based_Inter_CU_HO))
3056       {
3057          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
3058          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
3059       }
3060       else
3061          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
3062
3063       /* DL PDCP SN Length */
3064       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
3065       {
3066          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
3067          if(!drbToBeSetupExt)
3068          {
3069             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
3070             return RFAILED;
3071          }
3072
3073          elementCnt = 1;
3074          drbToBeSetupExt->list.count = elementCnt;
3075          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
3076
3077          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
3078          if(!drbToBeSetupExt->list.array)
3079          {
3080              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
3081              return RFAILED;
3082          }
3083
3084          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
3085          {
3086             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
3087             if(!drbToBeSetupExt->list.array[extIeIdx])
3088             {
3089                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
3090                return RFAILED;
3091             }
3092          }
3093
3094          extIeIdx = 0;
3095          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
3096
3097          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
3098          drbToBeSetupExtIe->criticality = Criticality_ignore;
3099          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
3100          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
3101          drbSetItem->iE_Extensions = drbToBeSetupExt;
3102       }
3103
3104       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3105          ueCb->numDrb++;
3106    }
3107    return ROK;
3108 }/* End of BuildDRBSetup*/
3109
3110 /*******************************************************************
3111  *
3112  * @brief Deallocating memory of function BuildAndSendUESetReq
3113  *
3114  * @details
3115  *
3116  *    Function : FreeNrcgi
3117  *
3118  *    Functionality: Deallocating memory for function BuildNrcgi
3119  *
3120  * @params[in] NRCGI_t *nrcgi
3121  *
3122  * @return void
3123  *
3124  *******************************************************************/
3125 void FreeNrcgi(NRCGI_t *nrcgi)
3126 {
3127    if(nrcgi->pLMN_Identity.buf != NULLP)
3128    {
3129       if(nrcgi->nRCellIdentity.buf != NULLP)
3130       {
3131          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
3132       }
3133       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
3134    }
3135 }
3136 /*******************************************************************
3137  *
3138  * @brief  Deallocating memory of function BuildAndSendUESetReq
3139  *
3140  * @details
3141  *
3142  *    Function : FreeSplCellList
3143  *
3144  *    Functionality: Deallocating memory for function BuildSplCellList
3145  *
3146  * @params[in] SCell_ToBeSetup_List_t *spCellLst
3147  *
3148  * @return void
3149  *
3150  *
3151  * *****************************************************************/
3152 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
3153 {
3154    uint8_t  cellidx;
3155    if(spCellLst->list.array != NULLP)
3156    {
3157       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
3158       {
3159          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
3160          {
3161             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
3162          }
3163          if(spCellLst->list.array[cellidx]!=NULLP)
3164          {
3165             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
3166          }
3167       }
3168       CU_FREE(spCellLst->list.array,spCellLst->list.size);
3169    }
3170 }
3171 /*******************************************************************
3172  *
3173  * @brief Deallocating memory of function BuildAndSendUESetReq
3174  *
3175  * @details
3176  *
3177  *    Function : FreeSRBSetup
3178  *
3179  *    Functionality: Deallocating memory for function BuildSRBSetup
3180  *
3181  * @params[in] SRBs_ToBeSetup_List_t *srbSet
3182  *
3183  * @return void
3184  *
3185  *
3186  * ******************************************************************/
3187 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
3188 {
3189    uint8_t srbidx;
3190    if(srbSet->list.array != NULLP)
3191    {
3192       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
3193       {
3194          if(srbSet->list.array[srbidx]!=NULLP)
3195          {
3196             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
3197          }
3198       }
3199       CU_FREE(srbSet->list.array,srbSet->list.size);
3200    }
3201 }
3202 /*******************************************************************
3203  *
3204  * @brief Deallocating memory of function BuildAndSendUESetReq
3205  *
3206  * @details
3207  *
3208  *    Function : FreeQOSInfo
3209  *
3210  *    Functionality:  Deallocating memory for function BuildQOSInfo
3211  *
3212  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
3213  *
3214  * @return void
3215  *
3216  * ****************************************************************/
3217 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
3218 {
3219    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3220    uint8_t qosCntIdx = 0;
3221
3222    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
3223    {
3224       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3225       {
3226          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3227          {
3228             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3229                   sizeof(MaxDataBurstVolume_t));
3230          }
3231          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3232                sizeof(AveragingWindow_t));
3233       }
3234       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3235             sizeof(NonDynamic5QIDescriptor_t));
3236    }
3237    if(drbQos->iE_Extensions)
3238    {
3239       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
3240       if(qosIeExt->list.array != NULLP)
3241       {
3242          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
3243          {
3244             if(qosIeExt->list.array[qosCntIdx])
3245             {
3246                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3247             }
3248          }
3249          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3250       }
3251
3252       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3253    }
3254 }
3255 /*******************************************************************
3256  *
3257  * @brief Deallocating memory of function BuildAndSendUESetReq
3258  *
3259  * @details
3260  *
3261  *    Function : FreeULTnlInfo
3262  *
3263  *    Functionality:  Deallocating memory for function BuildULTnlInfo
3264  *
3265  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
3266  *
3267  * @return void
3268  *
3269
3270  * ****************************************************************/
3271 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
3272 {
3273    uint8_t ulidx=0;
3274    if(ulInfo->list.array != NULLP)
3275    {
3276       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
3277       {
3278          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3279          {
3280             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3281             {
3282                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3283                      transportLayerAddress.buf != NULLP)
3284                {
3285                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3286                         !=NULLP)
3287                   {
3288                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3289                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3290                            gTPTunnel->gTP_TEID.size);
3291                   }
3292                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3293                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3294                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3295                }
3296                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3297                      sizeof(GTPTunnel_t));
3298             }
3299          }
3300          if(ulInfo->list.array[ulidx]!=NULLP)
3301          {
3302             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3303          }
3304       }
3305       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3306    }
3307 }
3308 /*******************************************************************
3309  *
3310  * @brief Deallocating memory for BuildAndSendUESetReq
3311  *
3312  * @details
3313  *
3314  *    Function : FreeDRBSetup
3315  *
3316  *    Functionality:  Deallocating memory for BuildDRBSetup
3317  *
3318  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3319  *
3320  * @return void
3321  *
3322  * ****************************************************************/
3323 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3324 {
3325    DRBs_ToBeSetup_Item_t *drbSetItem;
3326    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3327
3328    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3329
3330    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3331    if(drbSet->list.array != NULLP)
3332    {
3333       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3334       {
3335               if(drbSet->list.array[drbidx] != NULLP)
3336               {
3337                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3338                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3339                  {
3340                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3341                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3342                {
3343                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3344                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3345                             {
3346                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3347                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3348                                {
3349                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3350                                        {
3351                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3352                                           {
3353                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3354                                              {
3355                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3356                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3357                                                      {
3358                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3359                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3360                                                          {
3361                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3362                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3363                                                              {
3364                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3365                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3366                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3367                                                                      {
3368                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3369                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3370                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3371                                                                          {
3372                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3373                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3374                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3375                                                                                   {
3376                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3377                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3378
3379                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3380                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3381                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3382                                                                                                    sizeof(MaxDataBurstVolume_t));
3383                                                                                   }
3384                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3385                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3386                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3387                                                                          }
3388                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3389                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3390                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3391                                                                      }
3392                                                             }
3393                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3394                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3395                                                             {
3396                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3397                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3398                                                             }
3399                                                         }
3400                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3401                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3402                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3403                                                      }
3404                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3405                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3406                                             }
3407                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3408                                                               sizeof(OCTET_STRING_t));
3409                                        }
3410                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3411                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3412                                     }
3413                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3414                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3415                             }
3416                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3417                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3418                          }
3419                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3420                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3421              }
3422              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3423                         iE_Extensions != NULLP)
3424              {
3425                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3426                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3427                  if(qosIeExt->list.array != NULLP)
3428                  {
3429                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3430                    {
3431                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3432                       {
3433                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3434                       }
3435                     }
3436                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3437                   }
3438                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3439                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3440               }
3441
3442                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3443                 }
3444                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3445               }
3446       }
3447       CU_FREE(drbSet->list.array,drbSet->list.size);
3448    }
3449 }
3450
3451
3452 /*******************************************************************
3453  *
3454  * @brief Free the UE Setup Request
3455  *
3456  * @details
3457  *
3458  *    Function : FreeUeContextSetupReq
3459  *
3460  *    Functionality: Deallocate the memory of BuildUESetReq
3461  *
3462  * @params[in]  F1AP_PDU_t  *f1apMsg
3463  *
3464  * @return void
3465  *
3466  *
3467  * ****************************************************************/
3468 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3469 {
3470    uint8_t idx, ieId;
3471    UEContextSetupRequest_t  *ueSetReq = NULLP;
3472
3473    if(f1apMsg != NULLP)
3474    {
3475       if(f1apMsg->choice.initiatingMessage != NULLP)
3476       {
3477          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3478          if(ueSetReq->protocolIEs.list.array != NULLP)
3479          {
3480             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3481             {
3482                if(ueSetReq->protocolIEs.list.array[idx])
3483                {
3484                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3485                   {
3486                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3487                         break;
3488                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3489                         break;
3490                      case ProtocolIE_ID_id_SpCell_ID:
3491                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3492                         break;
3493                      case ProtocolIE_ID_id_ServCellIndex:
3494                         break;
3495                      case ProtocolIE_ID_id_SpCellULConfigured:
3496                         break;
3497                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3498                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3499                         break;
3500                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3501                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3502                         break;
3503                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3504                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3505                         break;
3506                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3507                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3508                         break;
3509                      case ProtocolIE_ID_id_RRCContainer:
3510                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3511                         {
3512                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3513                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3514                         }
3515                         break;
3516                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3517                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3518                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3519                         break;
3520                      default:
3521                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3522                         break;
3523                   }
3524                }
3525                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3526             }
3527             for(ieId=0; ieId<idx; ieId++)
3528             {
3529                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3530                {
3531                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3532                }
3533             }
3534             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3535          }
3536          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3537       }
3538       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3539    }
3540 }
3541
3542 /**Filling cell group info **/
3543 /*******************************************************************
3544  *
3545  * @brief Build Control resource set to add/modify list
3546  *
3547  * @details
3548  *
3549  *    Function : BuildControlRSetToAddModList
3550  *
3551  *    Functionality: Build Control resource set to add/modify list
3552  *
3553  * @params[in]
3554  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3555  *
3556  * @return ROK     - success
3557  *         RFAILED - failure
3558  *
3559  * ****************************************************************/
3560    uint8_t BuildControlRSetToAddModList
3561 (
3562  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3563  )
3564 {
3565    uint8_t idx;
3566    uint8_t elementCnt;
3567    uint8_t numBytes, bitsUnused;
3568    struct ControlResourceSet *controlRSet;
3569    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3570    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3571
3572    elementCnt = 1;
3573    controlRSetList->list.count = elementCnt;
3574    controlRSetList->list.size = \
3575                                 elementCnt * sizeof(struct ControlResourceSet *);
3576
3577    controlRSetList->list.array = NULLP;
3578    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3579    if(!controlRSetList->list.array)
3580    {
3581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3582       return RFAILED;
3583    }
3584
3585    for(idx = 0; idx < elementCnt; idx++)
3586    {
3587       controlRSetList->list.array[idx] = NULLP;
3588       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3589       if(!controlRSetList->list.array[idx])
3590       {
3591          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3592          return RFAILED;
3593       }
3594    }
3595
3596    idx=0;
3597    controlRSet = controlRSetList->list.array[idx];
3598    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3599
3600    /* Values harcoded according to our design:
3601     * size 6 bytes
3602     * 3 LSBs unsued
3603     * Bit string stored ff0000000000
3604     */
3605    numBytes = 6;
3606    bitsUnused = 3;
3607    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3608    controlRSet->frequencyDomainResources.buf = NULLP;
3609    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3610          controlRSet->frequencyDomainResources.size);
3611    if(!controlRSet->frequencyDomainResources.buf)
3612    {
3613       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3614       return RFAILED;
3615    }
3616
3617    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3618    coreset0EndPrb = CORESET0_END_PRB;
3619    coreset1StartPrb = coreset0EndPrb + 6;
3620    coreset1NumPrb = CORESET1_NUM_PRB;
3621    /* calculate the PRBs */
3622    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3623    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3624    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3625
3626    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3627    controlRSet->cce_REG_MappingType.present = \
3628                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3629
3630    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3631    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3632    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3633    controlRSet->tci_PresentInDCI = NULLP;
3634 #if 0
3635    uint8_t tciStateIdx;
3636
3637    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3638          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3639    if(!controlRset->tci_StatesPDCCH_ToAddList)
3640    {
3641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3642       return RFAILED;
3643    }
3644
3645    elementCnt = 1;
3646    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3647    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3648    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3649          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3650       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3651       {
3652          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3653          return RFAILED;
3654       }
3655
3656    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3657    {
3658       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3659       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3660       {
3661          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3662          return RFAILED;
3663       }
3664    }
3665
3666    tciStateIdx = 0;
3667    /* TODO */
3668    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3669
3670    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3671    if(!controlRset->tci_PresentInDCI)
3672    {
3673       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3674       return RFAILED;
3675    }
3676    /* TODO */
3677    *(controlRset->tci_PresentInDCI);
3678 #endif
3679
3680    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3681    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3682    if(!controlRSet->pdcch_DMRS_ScramblingID)
3683    {
3684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3685       return RFAILED;
3686    }
3687    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3688
3689    return ROK;
3690 } /* End BuildControlRSetToAddModList */
3691
3692 /*******************************************************************
3693  *
3694  * @brief Build search space to add/modify list
3695  *
3696  * @details
3697  *
3698  *    Function : BuildSearchSpcToAddModList
3699  *
3700  *    Functionality: Build search space to add/modify list
3701  *
3702  * @params[in]
3703  * @return ROK     - success
3704  *         RFAILED - failure
3705  *
3706  * ****************************************************************/
3707    uint8_t BuildSearchSpcToAddModList
3708 (
3709  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3710  )
3711 {
3712    uint8_t idx;
3713    uint8_t numBytes;
3714    uint8_t byteIdx;
3715    uint8_t bitsUnused;
3716    uint8_t elementCnt;
3717    struct SearchSpace *searchSpc;
3718
3719    elementCnt = 1;
3720    searchSpcList->list.count = elementCnt;
3721    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3722
3723    searchSpcList->list.array = NULLP;
3724    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3725    if(!searchSpcList->list.array)
3726    {
3727       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3728       return RFAILED;
3729    }
3730
3731    for(idx = 0; idx < elementCnt; idx++)
3732    {
3733       searchSpcList->list.array[idx] = NULLP;
3734       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3735       if(!searchSpcList->list.array[idx])
3736       {
3737          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3738          return RFAILED;
3739       }
3740    }
3741
3742    idx = 0;
3743    searchSpc = searchSpcList->list.array[idx];
3744
3745    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3746
3747    searchSpc->controlResourceSetId = NULLP;
3748    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3749    if(!searchSpc->controlResourceSetId)
3750    {
3751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3752       return RFAILED;
3753    }
3754    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3755
3756    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3757    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3758          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3759    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3760    {
3761       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3762       return RFAILED;
3763    }
3764    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3765                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3766
3767    searchSpc->duration = NULLP;
3768    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3769    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3770    if(!searchSpc->monitoringSymbolsWithinSlot)
3771    {
3772       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3773       return RFAILED;
3774    }
3775
3776    /* Values taken from reference logs :
3777     * size 2 bytes
3778     * 2 LSBs unsued
3779     * Bit string stores 8000
3780     */
3781    numBytes = 2;
3782    bitsUnused = 2;
3783
3784    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3785    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3786    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3787          searchSpc->monitoringSymbolsWithinSlot->size);
3788    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3789    {
3790       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3791       return RFAILED;
3792    }
3793
3794    byteIdx = 0;
3795    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3796                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3797    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3798    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3799
3800    searchSpc->nrofCandidates = NULLP;
3801    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3802    if(!searchSpc->nrofCandidates)
3803    {
3804       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3805       return RFAILED;
3806    }
3807
3808    searchSpc->nrofCandidates->aggregationLevel1 = \
3809                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3810    searchSpc->nrofCandidates->aggregationLevel2 = \
3811                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3812    searchSpc->nrofCandidates->aggregationLevel4 = \
3813                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3814    searchSpc->nrofCandidates->aggregationLevel8 = \
3815                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3816    searchSpc->nrofCandidates->aggregationLevel16 = \
3817                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3818
3819    searchSpc->searchSpaceType = NULLP;
3820    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3821    if(!searchSpc->searchSpaceType)
3822    {
3823       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3824       return RFAILED;
3825    }
3826
3827    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3828
3829    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3830    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3831          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3832    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3833    {
3834       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3835       return RFAILED;
3836    }
3837    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3838                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3839
3840    return ROK;
3841 }/* End BuildSearchSpcToAddModList */
3842
3843 /*******************************************************************
3844  *
3845  * @brief Builds BWP DL dedicated PDCCH config
3846  *
3847  * @details
3848  *
3849  *    Function : BuildBWPDlDedPdcchCfg
3850  *
3851  *    Functionality: Builds BWP DL dedicated PDCCH config
3852  *
3853  * @params[in] struct PDCCH_Config *pdcchCfg
3854  *
3855  * @return ROK     - success
3856  *         RFAILED - failure
3857  *
3858  * ****************************************************************/
3859 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3860 {
3861    pdcchCfg->controlResourceSetToAddModList = NULLP;
3862    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3863          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3864    if(!pdcchCfg->controlResourceSetToAddModList)
3865    {
3866       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3867       return RFAILED;
3868    }
3869
3870    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3871    {
3872       return RFAILED;
3873    }
3874
3875    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3876
3877    pdcchCfg->searchSpacesToAddModList = NULLP;
3878    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3879          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3880    if(!pdcchCfg->searchSpacesToAddModList)
3881    {
3882       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3883       return RFAILED;
3884    }
3885
3886    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3887    {
3888       return RFAILED;
3889    }
3890
3891    pdcchCfg->searchSpacesToReleaseList = NULLP;
3892    pdcchCfg->downlinkPreemption = NULLP;
3893    pdcchCfg->tpc_PUSCH = NULLP;
3894    pdcchCfg->tpc_PUCCH = NULLP;
3895    pdcchCfg->tpc_SRS = NULLP;
3896
3897    return ROK;
3898 }
3899
3900 /*******************************************************************
3901  *
3902  * @brief Builds DMRS DL PDSCH Mapping type A
3903  *
3904  * @details
3905  *
3906  *    Function : BuildDMRSDLPdschMapTypeA
3907  *
3908  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3909  *
3910  * @params[in]
3911  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3912  * @return ROK     - success
3913  *         RFAILED - failure
3914  *
3915  * ****************************************************************/
3916    uint8_t BuildDMRSDLPdschMapTypeA
3917 (
3918  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3919  )
3920 {
3921    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3922    dmrsDlCfg->choice.setup = NULLP;
3923    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3924    if(!dmrsDlCfg->choice.setup)
3925    {
3926       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3927       return RFAILED;
3928    }
3929
3930    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3931    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3932    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3933    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3934    {
3935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3936       return RFAILED;
3937    }
3938    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3939
3940    dmrsDlCfg->choice.setup->maxLength = NULLP;
3941    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3942    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3943    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3944
3945    return ROK;
3946 }
3947
3948 /*******************************************************************
3949  *
3950  * @brief Builds TCI states to add/modify list
3951  *
3952  * @details
3953  *
3954  *    Function : BuildTCIStatesToAddModList
3955  *
3956  *    Functionality:Builds TCI states to add/modify list
3957  *
3958  * @params[in]
3959  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3960  *
3961  * @return ROK     - success
3962  *         RFAILED - failure
3963  *
3964  * ****************************************************************/
3965 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3966 {
3967    return ROK;
3968 }
3969
3970 /*******************************************************************
3971  *
3972  * @brief Builds PDSCH time domain allocation list
3973  *
3974  * @details
3975  *
3976  *    Function : BuildPdschTimeDomAllocList
3977  *
3978  *    Functionality: Builds PDSCH time domain allocation list
3979  *
3980  * @params[in]
3981  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3982  *
3983  * @return ROK     - success
3984  *         RFAILED - failure
3985  *
3986  * ****************************************************************/
3987    uint8_t BuildPdschTimeDomAllocList
3988 (
3989  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3990  )
3991 {
3992    uint8_t idx;
3993    uint8_t elementCnt;
3994    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3995
3996    timeDomAllocList->present = \
3997                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3998
3999    timeDomAllocList->choice.setup = NULLP;
4000    CU_ALLOC(timeDomAllocList->choice.setup, \
4001          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4002    if(!timeDomAllocList->choice.setup)
4003    {
4004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4005       return RFAILED;
4006    }
4007
4008    elementCnt = 2;
4009    timeDomAllocList->choice.setup->list.count = elementCnt;
4010    timeDomAllocList->choice.setup->list.size = \
4011                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4012
4013    timeDomAllocList->choice.setup->list.array = NULLP;
4014    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4015          timeDomAllocList->choice.setup->list.size);
4016    if(!timeDomAllocList->choice.setup->list.array)
4017    {
4018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4019       return RFAILED;
4020    }
4021
4022    for(idx = 0; idx < elementCnt; idx++)
4023    {
4024       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4025       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4026             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4027       if(!timeDomAllocList->choice.setup->list.array[idx])
4028       {
4029          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4030          return RFAILED;
4031       }
4032    }
4033
4034    idx = 0;
4035    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4036    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4037    if(!timeDomAlloc->k0)
4038    {
4039        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4040        return RFAILED;
4041    }
4042    *(timeDomAlloc->k0) = 0;
4043    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4044    timeDomAlloc->startSymbolAndLength = 66;
4045
4046    idx++;
4047    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4048    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4049    if(!timeDomAlloc->k0)
4050    {
4051       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4052       return RFAILED;
4053    }
4054    *(timeDomAlloc->k0) = 1;
4055    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4056    timeDomAlloc->startSymbolAndLength = 66;
4057
4058    return ROK;
4059 }
4060
4061 /*******************************************************************
4062  *
4063  * @brief Builds PDSCH PRB Bundling type
4064  *
4065  * @details
4066  *
4067  *    Function : BuildPdschPrbBundlingType
4068  *
4069  *    Functionality: Builds PDSCH PRB Bundling type
4070  *
4071  * @params[in]
4072  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4073  *
4074  * @return ROK     - success
4075  *         RFAILED - failure
4076  *
4077  * ****************************************************************/
4078    uint8_t BuildPdschPrbBundlingType
4079 (
4080  struct PDSCH_Config__prb_BundlingType *prbBndlType
4081  )
4082 {
4083    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4084
4085    prbBndlType->choice.staticBundling = NULLP;
4086    CU_ALLOC(prbBndlType->choice.staticBundling, \
4087          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4088    if(!prbBndlType->choice.staticBundling)
4089    {
4090       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4091       return RFAILED;
4092    }
4093    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4094
4095    return ROK;
4096 }
4097
4098 /*******************************************************************
4099  *
4100  * @brief Builds BWP DL dedicated PDSCH config
4101  *
4102  * @details
4103  *
4104  *    Function : BuildBWPDlDedPdschCfg
4105  *
4106  *    Functionality: Builds BWP DL dedicated PDSCH config
4107  *
4108  * @params[in] struct PDSCH_Config *pdschCfg
4109  *
4110  * @return ROK     - success
4111  *         RFAILED - failure
4112  *
4113  * ****************************************************************/
4114 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4115 {
4116    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4117
4118    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4119    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4120          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4121    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4122    {
4123       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4124       return RFAILED;
4125    }
4126
4127    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4128    {
4129       return RFAILED;
4130    }
4131
4132    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4133    pdschCfg->tci_StatesToAddModList = NULLP;
4134    pdschCfg->tci_StatesToReleaseList = NULLP;
4135    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4136 #if 0
4137    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4138    if(!pdschCfg->tci_StatesToAddModList)
4139    {
4140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4141       return RFAILED;
4142    }
4143    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4144    {
4145       return RFAILED;
4146    }
4147 #endif
4148
4149    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4150
4151    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4152    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4153          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4154    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4155    {
4156       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4157       return RFAILED;
4158    }
4159    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4160    {
4161       return RFAILED;
4162    }
4163    pdschCfg->pdsch_AggregationFactor = NULLP;
4164    pdschCfg->rateMatchPatternToAddModList = NULLP;
4165    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4166    pdschCfg->rateMatchPatternGroup1 = NULLP;
4167    pdschCfg->rateMatchPatternGroup2 = NULLP;
4168    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4169    pdschCfg->mcs_Table = NULLP;
4170
4171    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4172    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4173    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4174    {
4175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4176       return RFAILED;
4177    }
4178    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4179
4180    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4181    {
4182       return RFAILED;
4183    }
4184
4185    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4186    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4187    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4188    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4189    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4190    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4191    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4192
4193    return ROK;
4194 }
4195
4196 /*******************************************************************
4197  *
4198  * @brief Builds intitial DL BWP
4199  * @details
4200  *
4201  *    Function : BuildInitialDlBWP
4202  *
4203  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4204  *
4205  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4206  *
4207  * @return ROK     - success
4208  *         RFAILED - failure
4209  *
4210  * ****************************************************************/
4211 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4212 {
4213    dlBwp->pdcch_Config = NULLP;
4214    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4215    if(!dlBwp->pdcch_Config)
4216    {
4217       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4218       return RFAILED;
4219    }
4220    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4221
4222    dlBwp->pdcch_Config->choice.setup = NULLP;
4223    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4224    if(!dlBwp->pdcch_Config->choice.setup)
4225    {
4226       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4227       return RFAILED;
4228    }
4229    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4230    {
4231       return RFAILED;
4232    }
4233
4234    dlBwp->pdsch_Config = NULLP;
4235    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4236    if(!dlBwp->pdsch_Config)
4237    {
4238       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4239       return RFAILED;
4240    }
4241    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4242
4243    dlBwp->pdsch_Config->choice.setup = NULLP;
4244    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4245    if(!dlBwp->pdsch_Config->choice.setup)
4246    {
4247       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4248       return RFAILED;
4249    }
4250
4251    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4252    {
4253       return RFAILED;
4254    }
4255
4256    dlBwp->sps_Config = NULLP;
4257    dlBwp->radioLinkMonitoringConfig = NULLP;
4258    return ROK;
4259 }
4260
4261 /*******************************************************************
4262  *
4263  * @brief Builds DMRS UL Pusch Mapping type A
4264  *
4265  * @details
4266  *
4267  *    Function : BuildDMRSULPuschMapTypeA
4268  *
4269  *    Functionality: Builds DMRS UL Pusch Mapping type A
4270  *
4271  * @params[in]
4272  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4273  * @return ROK     - success
4274  *         RFAILED - failure
4275  *
4276  * ****************************************************************/
4277    uint8_t BuildDMRSULPuschMapTypeA
4278 (
4279  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4280  )
4281 {
4282    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4283    dmrsUlCfg->choice.setup= NULLP;
4284    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4285    if(!dmrsUlCfg->choice.setup)
4286    {
4287       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4288       return RFAILED;
4289    }
4290
4291    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4292    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4293    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4294    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4295    {
4296       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4297       return RFAILED;
4298    }
4299    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4300
4301    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4302    dmrsUlCfg->choice.setup->maxLength = NULLP;
4303    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4304    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4305          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4306    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4307    {
4308       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4309       return RFAILED;
4310    }
4311
4312    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4313    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4314          sizeof(long));
4315    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4316    {
4317       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4318       return RFAILED;
4319    }
4320    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4321
4322    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4323    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4324    return ROK;
4325 }
4326
4327 /*******************************************************************
4328  *
4329  * @brief Build PUSCH time domain allocation list
4330  *
4331  * @details
4332  *
4333  *    Function : BuildPuschTimeDomAllocList
4334  *
4335  *    Functionality: Build PUSCH time domain allocation list
4336  *
4337  * @params[in]
4338  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4339  *
4340  * @return ROK     - success
4341  *         RFAILED - failure
4342  *
4343  * ****************************************************************/
4344    uint8_t BuildPuschTimeDomAllocList
4345 (
4346  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4347  )
4348 {
4349    uint8_t idx;
4350    uint8_t elementCnt;
4351    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4352
4353    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4354    timeDomAllocList->choice.setup = NULLP;
4355    CU_ALLOC(timeDomAllocList->choice.setup, \
4356          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4357    if(!timeDomAllocList->choice.setup)
4358    {
4359       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4360       return RFAILED;
4361    }
4362
4363    elementCnt = 2;
4364    timeDomAllocList->choice.setup->list.count = elementCnt;
4365    timeDomAllocList->choice.setup->list.size = \
4366                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4367    timeDomAllocList->choice.setup->list.array = NULLP;
4368    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4369          timeDomAllocList->choice.setup->list.size);
4370    if(!timeDomAllocList->choice.setup->list.array)
4371    {
4372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4373       return RFAILED;
4374    }
4375
4376    for(idx = 0; idx < elementCnt; idx++)
4377    {
4378       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4379       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4380             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4381       if(!timeDomAllocList->choice.setup->list.array[idx])
4382       {
4383          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4384          return RFAILED;
4385       }
4386    }
4387
4388    idx = 0;
4389    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4390    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4391    if(!timeDomAlloc->k2)
4392    {
4393       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4394       return RFAILED;
4395    }
4396    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4397    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4398    timeDomAlloc->startSymbolAndLength = 66;
4399
4400    idx++;
4401    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4402    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4403    if(!timeDomAlloc->k2)
4404    {
4405        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4406        return RFAILED;
4407    }
4408    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4409    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4410    timeDomAlloc->startSymbolAndLength = 66;
4411
4412    return ROK;
4413 }
4414
4415 /*******************************************************************
4416  *
4417  * @brief Builds BWP UL dedicated PUSCH Config
4418  *
4419  * @details
4420  *
4421  *    Function : BuildBWPUlDedPuschCfg
4422  *
4423  *    Functionality:
4424  *      Builds BWP UL dedicated PUSCH Config
4425  *
4426  * @params[in] : PUSCH_Config_t *puschCfg
4427  *
4428  * @return ROK     - success
4429  *         RFAILED - failure
4430  *
4431  * ****************************************************************/
4432 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4433 {
4434    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4435    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4436    if(!puschCfg->dataScramblingIdentityPUSCH)
4437    {
4438       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4439       return RFAILED;
4440    }
4441    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4442
4443    puschCfg->txConfig = NULLP;
4444    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4445    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4446          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4447    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4448    {
4449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4450       return RFAILED;
4451    }
4452
4453    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4454    {
4455       return RFAILED;
4456    }
4457
4458    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4459    puschCfg->pusch_PowerControl = NULLP;
4460    puschCfg->frequencyHopping = NULLP;
4461    puschCfg->frequencyHoppingOffsetLists = NULLP;
4462    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4463
4464    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4465    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4466          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4467    if(!puschCfg->pusch_TimeDomainAllocationList)
4468    {
4469       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4470       return RFAILED;
4471    }
4472
4473    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4474    {
4475       return RFAILED;
4476    }
4477
4478    puschCfg->pusch_AggregationFactor = NULLP;
4479    puschCfg->mcs_Table = NULLP;
4480    puschCfg->mcs_TableTransformPrecoder = NULLP;
4481    puschCfg->transformPrecoder = NULLP;
4482    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4483    if(!puschCfg->transformPrecoder)
4484    {
4485       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4486       return RFAILED;
4487    }
4488    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4489
4490    puschCfg->codebookSubset = NULLP;
4491    puschCfg->maxRank = NULLP;
4492    puschCfg->rbg_Size = NULLP;
4493    puschCfg->uci_OnPUSCH = NULLP;
4494    puschCfg->tp_pi2BPSK = NULLP;
4495
4496    return ROK;
4497 }
4498
4499 /*******************************************************************
4500  *
4501  * @brief Builds BWP UL dedicated PUCCH Config
4502  *
4503  * @details
4504  *
4505  *    Function : BuildBWPUlDedPucchCfg
4506  *
4507  *    Functionality:
4508  *      Builds BWP UL dedicated PUCCH Config
4509  *
4510  * @params[in] : PUCCH_Config_t *pucchCfg
4511  *
4512  * @return ROK     - success
4513  *         RFAILED - failure
4514  *
4515  * ****************************************************************/
4516 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4517 {
4518    uint8_t arrIdx, elementCnt;
4519    uint8_t rsrcIdx, rsrcSetIdx;
4520    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4521    PUCCH_Resource_t *rsrc = NULLP;
4522
4523    //RESOURCE SET
4524    elementCnt = 1;
4525    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4526    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4527    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4528    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4529    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4530    {
4531       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4532    }
4533    rsrcSetIdx = 0;
4534    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4535    rsrcSet->pucch_ResourceSetId = 1;
4536    elementCnt = 1;
4537    rsrcSet->resourceList.list.count = elementCnt;
4538    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4539    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4540    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4541    {
4542       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4543    }
4544    rsrcIdx = 0;
4545    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4546
4547    //RESOURCE
4548    elementCnt = 1;
4549    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4550    pucchCfg->resourceToAddModList->list.count = elementCnt;
4551    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4552    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4553    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4554    {
4555       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4556    }
4557    rsrcIdx = 0;
4558    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4559    rsrc->pucch_ResourceId = 1;
4560    rsrc->startingPRB = 0;
4561    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4562    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4563    rsrc->format.choice.format1->initialCyclicShift = 0;
4564    rsrc->format.choice.format1->nrofSymbols = 4;
4565    rsrc->format.choice.format1->startingSymbolIndex = 0;
4566    rsrc->format.choice.format1->timeDomainOCC = 0;
4567
4568    //PUCCH Format 1
4569    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4570    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4571    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4572    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4573    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4574
4575    //DL DATA TO UL ACK
4576    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4577    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4578    {
4579       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4580       return RFAILED;
4581    }
4582
4583    elementCnt = 2;
4584    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4585    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4586    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4587    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4588    {
4589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4590       return RFAILED;
4591    }
4592
4593    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4594    {
4595       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4596       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4597       {
4598           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4599           return RFAILED;
4600       }
4601    }
4602
4603    arrIdx = 0;
4604    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4605    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4606
4607    return ROK;
4608 }
4609
4610 /*******************************************************************
4611  *
4612  * @brief Fills SRS resource to add/modify list
4613  *
4614  * @details
4615  *
4616  *    Function : BuildSrsRsrcAddModList
4617  *
4618  *    Functionality: Fills SRS resource to add/modify list
4619  *
4620  * @params[in]
4621  * @return ROK     - success
4622  *         RFAILED - failure
4623  *
4624  * ****************************************************************/
4625 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4626 {
4627    uint8_t   elementCnt;
4628    uint8_t   rsrcIdx;
4629
4630    elementCnt = 1;
4631    resourceList->list.count = elementCnt;
4632    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4633    resourceList->list.array = NULLP;
4634    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4635    if(!resourceList->list.array)
4636    {
4637       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4638       return RFAILED;
4639    }
4640
4641    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4642    {
4643       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4644       if(!resourceList->list.array[rsrcIdx])
4645       {
4646          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4647          return RFAILED;
4648       }
4649    }
4650
4651    rsrcIdx = 0;
4652    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4653    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4654    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4655
4656    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4657    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4658          sizeof(struct SRS_Resource__transmissionComb__n2));
4659    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4660    {
4661       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4662       return RFAILED;
4663    }
4664    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4665       = SRS_COMB_OFFSET_N2;
4666    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4667       = SRS_CYCLIC_SHIFT_N2;
4668
4669    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4670    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4671                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4672    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4673                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4674
4675    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4676    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4677    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4678    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4679    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4680    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4681                                                                SRS_Resource__groupOrSequenceHopping_neither;
4682
4683    /* Setting resource type to aperiodic for intergration purposes */
4684    resourceList->list.array[rsrcIdx]->resourceType.present = \
4685                                                              SRS_Resource__resourceType_PR_aperiodic;
4686    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4687    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4688          sizeof(struct SRS_Resource__resourceType__aperiodic));
4689    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4690    {
4691       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4692       return RFAILED;
4693    }
4694    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4695
4696    return ROK;
4697 }
4698
4699 /*******************************************************************
4700  *
4701  * @brief Build SRS resource set Add/mod list
4702  *
4703  * @details
4704  *
4705  *    Function : BuildSrsRsrcSetAddModList
4706  *
4707  *    Functionality: Build SRS resource set Add/mod list
4708  *
4709  * @params[in]
4710  * @return ROK     - success
4711  *         RFAILED - failure
4712  *
4713  * ****************************************************************/
4714    uint8_t BuildSrsRsrcSetAddModList
4715 (
4716  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4717  )
4718 {
4719    uint8_t  elementCnt;
4720    uint8_t  rSetIdx;
4721    uint8_t  rsrcIdx;
4722    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4723
4724    elementCnt = 1;
4725    rsrcSetList->list.count = elementCnt;
4726    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4727    rsrcSetList->list.array = NULLP;
4728    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4729    if(!rsrcSetList->list.array)
4730    {
4731       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4732       return RFAILED;
4733    }
4734
4735    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4736    {
4737       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4738       if(!rsrcSetList->list.array[rSetIdx])
4739       {
4740          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4741          return RFAILED;
4742       }
4743    }
4744
4745    rSetIdx = 0;
4746    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4747
4748    /* Fill Resource Id list in resource set */
4749    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4750    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4751          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4752    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4753    {
4754       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4755       return RFAILED;
4756    }
4757
4758    elementCnt = 1;
4759    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4760    rsrcIdList->list.count = elementCnt;
4761    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4762    rsrcIdList->list.array = NULLP;
4763    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4764    if(!rsrcIdList->list.array)
4765    {
4766       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4767       return RFAILED;
4768    }
4769
4770    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4771    {
4772       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4773       if(!rsrcIdList->list.array[rsrcIdx])
4774       {
4775          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4776          return RFAILED;
4777       }
4778    }
4779
4780    rsrcIdx = 0;
4781    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4782
4783    /* Fill resource type */
4784    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4785                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4786
4787    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4788    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4789          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4790    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4791    {
4792       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4793       return RFAILED;
4794    }
4795    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4796       = APERIODIC_SRS_RESRC_TRIGGER;
4797
4798    /* TODO : Fill values for below IEs as expected by Viavi */
4799    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4800    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4801
4802
4803    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4804    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4805    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4806    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4807    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4808
4809    return ROK;
4810 }
4811
4812 /*******************************************************************
4813  *
4814  * @brief Builds BWP UL dedicated SRS Config
4815  *
4816  * @details
4817  *
4818  *    Function : BuildBWPUlDedSrsCfg
4819  *
4820  *    Functionality: Builds BWP UL dedicated SRS Config
4821  *
4822  * @params[in] SRS Config
4823  * @return ROK     - success
4824  *         RFAILED - failure
4825  *
4826  * ****************************************************************/
4827 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4828 {
4829    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4830    srsCfg->srs_ResourceSetToAddModList = NULLP;
4831    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4832          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4833    if(!srsCfg->srs_ResourceSetToAddModList)
4834    {
4835       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4836       return RFAILED;
4837    }
4838    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4839    {
4840       return RFAILED;
4841    }
4842
4843    srsCfg->srs_ResourceToReleaseList = NULLP;
4844
4845    /* Resource to Add/Modify list */
4846    srsCfg->srs_ResourceToAddModList = NULLP;
4847    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4848          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4849    if(!srsCfg->srs_ResourceToAddModList)
4850    {
4851       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4852       return RFAILED;
4853    }
4854
4855    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4856    {
4857       return RFAILED;
4858    }
4859
4860    srsCfg->tpc_Accumulation = NULLP;
4861
4862    return ROK;
4863 }
4864
4865 /*******************************************************************
4866  *
4867  * @brief Builds inital UL BWP
4868  *
4869  * @details
4870  *
4871  *    Function : BuildInitialUlBWP
4872  *
4873  *    Functionality: Builds initial UL BWP
4874  *
4875  * @params[in] BWP_UplinkDedicated_t *ulBwp
4876  * @return ROK     - success
4877  *         RFAILED - failure
4878  *
4879  * ****************************************************************/
4880 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4881 {
4882    ulBwp->pucch_Config = NULLP;
4883    ulBwp->pucch_Config = NULLP;
4884    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4885    if(!ulBwp->pucch_Config)
4886    {
4887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4888       return RFAILED;
4889    }
4890
4891    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4892    ulBwp->pucch_Config->choice.setup = NULLP;
4893    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4894    if(!ulBwp->pucch_Config->choice.setup)
4895    {
4896       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4897       return RFAILED;
4898    }
4899
4900    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4901    {
4902       return RFAILED;
4903    }
4904
4905    /* Fill BWP UL dedicated PUSCH config */
4906    ulBwp->pusch_Config = NULLP;
4907    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4908    if(!ulBwp->pusch_Config)
4909    {
4910       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4911       return RFAILED;
4912    }
4913
4914    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4915    ulBwp->pusch_Config->choice.setup = NULLP;
4916    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4917    if(!ulBwp->pusch_Config->choice.setup)
4918    {
4919       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4920       return RFAILED;
4921    }
4922
4923    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4924    {
4925       return RFAILED;
4926    }
4927
4928    ulBwp->configuredGrantConfig = NULLP;
4929
4930    /* Fill BPW UL dedicated SRS config */
4931    ulBwp->srs_Config = NULLP;
4932    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4933    if(!ulBwp->srs_Config)
4934    {
4935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4936       return RFAILED;
4937    }
4938
4939    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4940    ulBwp->srs_Config->choice.setup = NULLP;
4941    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4942    if(!ulBwp->srs_Config->choice.setup)
4943    {
4944       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4945       return RFAILED;
4946    }
4947
4948    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4949    {
4950       return RFAILED;
4951    }
4952
4953    ulBwp->beamFailureRecoveryConfig = NULLP;
4954
4955    return ROK;
4956 }
4957
4958 /*******************************************************************
4959  *
4960  * @brief Builds Pusch Serving cell Config
4961  *
4962  * @details
4963  *
4964  *    Function : BuildPuschSrvCellCfg
4965  *
4966  *    Functionality: Builds Pusch Serving cell Config
4967  *
4968  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4969  *
4970  * @return ROK     - success
4971  *         RFAILED - failure
4972  *
4973  * ****************************************************************/
4974 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4975 {
4976    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4977    puschCfg->choice.setup = NULLP;
4978    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4979    if(!puschCfg->choice.setup)
4980    {
4981       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4982       return RFAILED;
4983    }
4984
4985    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4986    puschCfg->choice.setup->rateMatching = NULLP;
4987    puschCfg->choice.setup->xOverhead = NULLP;
4988    puschCfg->choice.setup->ext1 = NULLP;
4989    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4990    if(!puschCfg->choice.setup->ext1)
4991    {
4992       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4993       return RFAILED;
4994    }
4995
4996    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4997    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4998    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4999    {
5000       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5001       return RFAILED;
5002    }
5003    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5004
5005    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5006    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5007    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5008    {
5009       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5010       return RFAILED;
5011    }
5012    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5013    return ROK;
5014 }
5015
5016 /*******************************************************************
5017  *
5018  * @brief Builds UL config
5019  * @details
5020  *
5021  *    Function : BuildUlCfg
5022  *
5023  *    Functionality: Builds UL config in spCellCfgDed
5024  *
5025  * @params[in] UplinkConfig_t *ulCfg
5026  *
5027  * @return ROK     - success
5028  *         RFAILED - failure
5029  *
5030  * ****************************************************************/
5031 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
5032 {
5033    ulCfg->initialUplinkBWP = NULLP;
5034    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5035    if(!ulCfg->initialUplinkBWP)
5036    {
5037       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5038       return RFAILED;
5039    }
5040
5041    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
5042    {
5043       return RFAILED;
5044    }
5045
5046    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5047    ulCfg->uplinkBWP_ToAddModList = NULLP;
5048    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5049    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5050    if(!ulCfg->firstActiveUplinkBWP_Id)
5051    {
5052       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5053       return RFAILED;
5054    }
5055    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5056
5057    ulCfg->pusch_ServingCellConfig = NULLP;
5058    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
5059          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5060    if(!ulCfg->pusch_ServingCellConfig)
5061    {
5062       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5063       return RFAILED;
5064    }
5065
5066    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5067    {
5068       return RFAILED;
5069    }
5070
5071    ulCfg->carrierSwitching = NULLP;
5072    ulCfg->ext1 = NULLP;
5073    return ROK;
5074 }
5075
5076 /*******************************************************************
5077  *
5078  * @brief Builds PDSCH serving cell config
5079  * @details
5080  *
5081  *    Function : BuildPdschSrvCellCfg
5082  *
5083  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5084  *
5085  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5086  *
5087  * @return ROK     - success
5088  *         RFAILED - failure
5089  *
5090  * ****************************************************************/
5091 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5092 {
5093    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5094    pdschCfg->choice.setup = NULLP;
5095    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5096    if(!pdschCfg->choice.setup)
5097    {
5098       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5099       return RFAILED;
5100    }
5101
5102    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5103    pdschCfg->choice.setup->xOverhead = NULLP;
5104    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5105    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5106    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5107    {
5108       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5109       return RFAILED;
5110    }
5111    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5112    pdschCfg->choice.setup->pucch_Cell = NULLP;
5113    pdschCfg->choice.setup->ext1 = NULLP;
5114
5115    return ROK;
5116 }
5117
5118 /*******************************************************************
5119  *
5120  * @brief Builds CSI Meas config
5121  * @details
5122  *
5123  *    Function : BuildCsiMeasCfg
5124  *
5125  *    Functionality: Builds CSI Meas config in spCellCfgDed
5126  *
5127  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5128  *
5129  * @return ROK     - success
5130  *         RFAILED - failure
5131  *
5132  * ****************************************************************/
5133 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5134 {
5135
5136    return ROK;
5137 }
5138
5139 /*******************************************************************
5140  *
5141  * @brief Builds Spcell config dedicated
5142  * @details
5143  *
5144  *    Function : BuildSpCellCfgDed
5145  *
5146  *    Functionality: Builds sp cell config dedicated in spCellCfg
5147  *
5148  * @params[in] ServingCellConfig_t srvCellCfg
5149  *
5150  * @return ROK     - success
5151  *         RFAILED - failure
5152  *
5153  * ****************************************************************/
5154 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5155 {
5156    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5157
5158    srvCellCfg->initialDownlinkBWP = NULLP;
5159    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5160    if(!srvCellCfg->initialDownlinkBWP)
5161    {
5162       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5163       return RFAILED;
5164    }
5165
5166    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5167    {
5168       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5169       return RFAILED;
5170    }
5171    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5172    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5173
5174    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5175    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5176    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5177    {
5178       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5179       return RFAILED;
5180    }
5181    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5182
5183    srvCellCfg->bwp_InactivityTimer = NULLP;
5184
5185    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5186    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5187    if(!srvCellCfg->defaultDownlinkBWP_Id)
5188    {
5189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5190       return RFAILED;
5191    }
5192    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5193
5194    srvCellCfg->uplinkConfig = NULLP;
5195    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5196    if(!srvCellCfg->uplinkConfig)
5197    {
5198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5199       return RFAILED;
5200    }
5201
5202    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5203    {
5204       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5205       return RFAILED;
5206    }
5207    srvCellCfg->supplementaryUplink = NULLP;
5208    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5209
5210    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5211    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5212    if(!srvCellCfg->pdsch_ServingCellConfig)
5213    {
5214       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5215       return RFAILED;
5216    }
5217
5218    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5219    {
5220       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5221       return RFAILED;
5222    }
5223
5224    srvCellCfg->csi_MeasConfig = NULLP;
5225 #if 0
5226    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5227       if(!srvCellCfg->csi_MeasConfig)
5228       {
5229          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5230          return RFAILED;
5231       }
5232
5233    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5234    {
5235       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5236       return RFAILED;
5237    }
5238 #endif
5239    srvCellCfg->sCellDeactivationTimer = NULLP;
5240    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5241    srvCellCfg->tag_Id = TAG_ID;
5242    srvCellCfg->dummy = NULLP;
5243    srvCellCfg->pathlossReferenceLinking = NULLP;
5244    srvCellCfg->servingCellMO = NULLP;
5245    srvCellCfg->ext1 = NULLP;
5246
5247    return ROK;
5248 }
5249 /*******************************************************************
5250  *
5251  * @brief Builds Spcell config
5252  *
5253  * @details
5254  *
5255  *    Function : BuildSpCellCfg
5256  *
5257  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5258  *
5259  * @params[in] SpCellConfig_t spCellCfg
5260  *
5261  * @return ROK     - success
5262  *         RFAILED - failure
5263  *
5264  * ****************************************************************/
5265 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5266 {
5267
5268    spCellCfg->servCellIndex = NULLP;
5269    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5270    if(!spCellCfg->servCellIndex)
5271    {
5272       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5273       return RFAILED;
5274    }
5275    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5276
5277    spCellCfg->reconfigurationWithSync = NULLP;
5278    spCellCfg->rlf_TimersAndConstants = NULLP;
5279    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5280    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5281    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5282    {
5283       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5284       return RFAILED;
5285    }
5286    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5287
5288    spCellCfg->spCellConfigDedicated = NULLP;
5289    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5290    if(!spCellCfg->spCellConfigDedicated)
5291    {
5292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5293       return RFAILED;
5294    }
5295    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5296    {
5297       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5298       return RFAILED;
5299    }
5300    return ROK;
5301 }
5302 /*******************************************************************
5303  *
5304  * @brief Builds Phy cell group config
5305  *
5306  * @details
5307  *
5308  *    Function : BuildPhyCellGrpCfg
5309  *
5310  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5311  *
5312  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5313  *
5314  * @return ROK     - success
5315  *         RFAILED - failure
5316  *
5317  * ****************************************************************/
5318 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5319 {
5320    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5321    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5322
5323    phyCellGrpCfg->p_NR_FR1 = NULLP;
5324    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5325    if(!phyCellGrpCfg->p_NR_FR1)
5326    {
5327       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5328       return RFAILED;
5329    }
5330    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5331    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5332    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5333    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5334    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5335    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5336    phyCellGrpCfg->cs_RNTI = NULLP;
5337    phyCellGrpCfg->ext1 = NULLP;
5338    phyCellGrpCfg->ext2 = NULLP;
5339
5340    return ROK;
5341 }
5342
5343 /*******************************************************************
5344  *
5345  * @brief Builds tag config
5346  *
5347  * @details
5348  *
5349  *    Function : BuildTagConfig
5350  *
5351  *    Functionality: Builds tag config in MacCellGroupConfig
5352  *
5353  * @params[in] TAG_Config *tag_Config
5354  *
5355  * @return ROK     - success
5356  *         RFAILED - failure
5357  *
5358  * ****************************************************************/
5359 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5360 {
5361    struct TAG_Config__tag_ToAddModList *tagList;
5362    uint8_t                     idx, elementCnt;
5363
5364    tagConfig->tag_ToReleaseList = NULLP;
5365    tagConfig->tag_ToAddModList = NULLP;
5366    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5367    if(!tagConfig->tag_ToAddModList)
5368    {
5369       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5370       return RFAILED;
5371    }
5372
5373    elementCnt = 1; //ODU_VALUE_ONE;
5374    tagList = tagConfig->tag_ToAddModList;
5375    tagList->list.count = elementCnt;
5376    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5377
5378    tagList->list.array = NULLP;
5379    CU_ALLOC(tagList->list.array, tagList->list.size);
5380    if(!tagList->list.array)
5381    {
5382       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5383       return RFAILED;
5384    }
5385
5386    for(idx=0; idx<tagList->list.count; idx++)
5387    {
5388       tagList->list.array[idx] = NULLP;
5389       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5390       if(!tagList->list.array[idx])
5391       {
5392          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5393          return RFAILED;
5394       }
5395    }
5396
5397    idx = 0;
5398    tagList->list.array[idx]->tag_Id = TAG_ID;
5399    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5400
5401    return ROK;
5402 }
5403
5404 /*******************************************************************
5405  *
5406  * @brief Builds PHR Config
5407  *
5408  * @details
5409  *
5410  *    Function : BuildPhrConfig
5411  *
5412  *    Functionality: Builds phrConfig in MacCellGroupConfig
5413  *
5414  * @params[in] PHR Config *
5415  *
5416  * @return ROK     - success
5417  *         RFAILED - failure
5418  *
5419  * ****************************************************************/
5420 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5421 {
5422
5423    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5424    phrConfig->choice.setup = NULLP;
5425    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5426    if(!phrConfig->choice.setup)
5427    {
5428       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5429       return RFAILED;
5430    }
5431
5432    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5433    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5434    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5435    phrConfig->choice.setup->multiplePHR              = false;
5436    phrConfig->choice.setup->dummy                    = false;
5437    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5438    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5439
5440    return ROK;
5441 }
5442
5443 /*******************************************************************
5444  *
5445  * @brief Builds BSR Config
5446  *
5447  * @details
5448  *
5449  *    Function : BuildBsrConfig
5450  *
5451  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5452  *
5453  * @params[in] BSR_Config *bsrConfig
5454  *
5455  * @return ROK     - success
5456  *         RFAILED - failure
5457  *
5458  * ****************************************************************/
5459 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5460 {
5461    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5462    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5463    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5464
5465    return ROK;
5466 }
5467
5468 /*******************************************************************
5469  *
5470  * @brief Builds scheduling request config
5471  *
5472  * @details
5473  *
5474  *    Function : BuildSchedulingReqConfig
5475  *
5476  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5477  *
5478  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5479  *
5480  * @return ROK     - success
5481  *         RFAILED - failure
5482  *
5483  * ****************************************************************/
5484 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5485 {
5486    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5487    uint8_t                     idx, elementCnt;
5488
5489    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5490    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5491          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5492    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5493    {
5494       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5495       return RFAILED;
5496    }
5497
5498    elementCnt = 1; //ODU_VALUE_ONE;
5499    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5500    schReqList->list.count = elementCnt;
5501    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5502
5503    schReqList->list.array = NULLP;
5504    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5505    if(!schReqList->list.array)
5506    {
5507       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5508       return RFAILED;
5509    }
5510
5511    for(idx=0;idx<schReqList->list.count; idx++)
5512    {
5513       schReqList->list.array[idx] = NULLP;
5514       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5515       if(!schReqList->list.array[idx])
5516       {
5517          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5518          return RFAILED;
5519       }
5520    }
5521
5522    idx = 0;
5523    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5524
5525    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5526    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5527    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5528    {
5529       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5530       return RFAILED;
5531    }
5532    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5533    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5534    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5535
5536    return ROK;
5537 }
5538 /*******************************************************************
5539  *
5540  * @brief Builds Mac cell group config
5541  *
5542  * @details
5543  *
5544  *    Function : BuildMacCellGrpCfg
5545  *
5546  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5547  *
5548  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5549  *
5550  * @return ROK     - success
5551  *         RFAILED - failure
5552  *
5553  * ****************************************************************/
5554 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5555 {
5556    macCellGrpCfg->drx_ConfigRrc = NULLP;
5557    macCellGrpCfg->schedulingRequestConfig = NULLP;
5558    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5559    if(!macCellGrpCfg->schedulingRequestConfig)
5560    {
5561       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5562       return RFAILED;
5563    }
5564
5565    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5566    {
5567       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5568       return RFAILED;
5569    }
5570
5571    macCellGrpCfg->bsr_Config = NULLP;
5572    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5573    if(!macCellGrpCfg->bsr_Config)
5574    {
5575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5576       return RFAILED;
5577    }
5578
5579    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5580    {
5581       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5582       return RFAILED;
5583    }
5584
5585    macCellGrpCfg->tag_Config = NULLP;
5586    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5587    if(!macCellGrpCfg->tag_Config)
5588    {
5589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5590       return RFAILED;
5591    }
5592
5593    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5594    {
5595       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5596       return RFAILED;
5597    }
5598
5599    macCellGrpCfg->phr_Config = NULLP;
5600    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5601    if(!macCellGrpCfg->phr_Config)
5602    {
5603       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5604       return RFAILED;
5605    }
5606
5607    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5608    {
5609       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5610       return RFAILED;
5611    }
5612
5613    macCellGrpCfg->skipUplinkTxDynamic = false;
5614    macCellGrpCfg->ext1 = NULLP;
5615
5616    return ROK;
5617 }
5618 /*******************************************************************
5619  *
5620  * @brief Frees memeory allocated for SearchSpcToAddModList
5621  *
5622  * @details
5623  *
5624  *    Function : FreeSearchSpcToAddModList
5625  *
5626  *    Functionality: Deallocating memory of SearchSpcToAddModList
5627  *
5628  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5629  *
5630  * @return void
5631  *
5632  4221 * ****************************************************************/
5633 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5634 {
5635    uint8_t idx1=0;
5636    uint8_t idx2=0;
5637    struct  SearchSpace *searchSpc=NULLP;
5638
5639    if(searchSpcList->list.array)
5640    {
5641       if(searchSpcList->list.array[idx2])
5642       {
5643          searchSpc = searchSpcList->list.array[idx2];
5644          if(searchSpc->controlResourceSetId)
5645          {
5646             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5647             {
5648                if(searchSpc->monitoringSymbolsWithinSlot)
5649                {
5650                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5651                   {
5652                      if(searchSpc->nrofCandidates)
5653                      {
5654                         if(searchSpc->searchSpaceType)
5655                         {
5656                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5657                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5658                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5659                                     SearchSpace__searchSpaceType));
5660                         }
5661                         CU_FREE(searchSpc->nrofCandidates,
5662                               sizeof(struct SearchSpace__nrofCandidates));
5663                      }
5664                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5665                            searchSpc->monitoringSymbolsWithinSlot->size);
5666                   }
5667                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5668                         sizeof(BIT_STRING_t));
5669                }
5670                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5671                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5672             }
5673             CU_FREE(searchSpc->controlResourceSetId,
5674                   sizeof(ControlResourceSetId_t));
5675          }
5676       }
5677       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5678       {
5679          CU_FREE(searchSpcList->list.array[idx1],
5680                sizeof(struct SearchSpace));
5681       }
5682       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5683    }
5684 }
5685 /*******************************************************************
5686  *
5687  * @brief Frees memory allocated for PdschTimeDomAllocList
5688  *
5689  * @details
5690  *
5691  *    Function : FreePdschTimeDomAllocList
5692  *
5693  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5694  *
5695  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5696  *
5697  * @return void
5698  *
5699  4221 * ****************************************************************/
5700 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5701 {
5702    uint8_t idx1=0;
5703
5704    if(timeDomAllocList->choice.setup)
5705    {
5706       if(timeDomAllocList->choice.setup->list.array)
5707       {
5708          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5709          {
5710             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5711                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5712          }
5713          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5714                timeDomAllocList->choice.setup->list.size);
5715       }
5716       CU_FREE(timeDomAllocList->choice.setup,\
5717             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5718    }
5719 }
5720 /*******************************************************************
5721  *
5722  * @brief Frees memory allocated for PuschTimeDomAllocList
5723  *
5724  *@details
5725  *
5726  *    Function : FreePuschTimeDomAllocList
5727  *
5728  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5729  *
5730  * @params[in] PUSCH_Config_t *puschCfg
5731  *
5732  * @return void
5733  *
5734  ***********************************************************************/
5735 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5736 {
5737    uint8_t idx1=0;
5738    uint8_t idx2=0;
5739    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5740
5741    if(puschCfg->pusch_TimeDomainAllocationList)
5742    {
5743       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5744       if(timeDomAllocList_t->choice.setup)
5745       {
5746          if(timeDomAllocList_t->choice.setup->list.array)
5747          {
5748             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5749             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5750             {
5751                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5752                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5753             }
5754             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5755                   timeDomAllocList_t->choice.setup->list.size);
5756          }
5757          CU_FREE(timeDomAllocList_t->choice.setup, \
5758                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5759       }
5760       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5761       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5762             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5763    }
5764
5765 }
5766
5767 /*******************************************************************
5768  *
5769  * @brief Frees memory allocated for Dedicated PUCCH config
5770  *
5771  * @details
5772  *
5773  *    Function : FreeBWPUlDedPucchCfg
5774  *
5775  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5776  *
5777  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5778  *
5779  * @return void
5780  *
5781  * ****************************************************************/
5782 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5783 {
5784    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5785    PUCCH_Config_t *pucchCfg = NULLP;
5786    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5787    PUCCH_Resource_t *rsrc = NULLP;
5788
5789    if(ulBwpPucchCfg)
5790    {
5791       if(ulBwpPucchCfg->choice.setup)
5792       {
5793          pucchCfg = ulBwpPucchCfg->choice.setup;
5794
5795          //Free resource set list
5796          if(pucchCfg->resourceSetToAddModList)
5797          {
5798             if(pucchCfg->resourceSetToAddModList->list.array)
5799             {
5800                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5801                {
5802                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5803                   if(rsrcSet->resourceList.list.array)
5804                   {
5805                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5806                      {
5807                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5808                      }
5809                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5810                   }
5811                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5812                }
5813                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5814             }
5815             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5816          }
5817
5818          //Free resource list
5819          if(pucchCfg->resourceToAddModList)
5820          {
5821             if(pucchCfg->resourceToAddModList->list.array)
5822             {
5823                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5824                {
5825                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5826                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5827                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5828                }
5829                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5830             }
5831             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5832          }
5833
5834          //PUCCH Format 1
5835          if(pucchCfg->format1)
5836          {
5837             if(pucchCfg->format1->choice.setup)
5838             {
5839                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5840                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5841             }
5842             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5843          }
5844
5845          //DL DATA TO UL ACK
5846          if(pucchCfg->dl_DataToUL_ACK)
5847          {
5848             if(pucchCfg->dl_DataToUL_ACK->list.array)
5849             {
5850                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5851                {
5852                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5853                }
5854                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5855             }
5856             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5857          }
5858
5859          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5860       }
5861       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5862    }
5863 }
5864
5865 /*******************************************************************
5866  *
5867  * @brief Frees memory allocated for InitialUlBWP
5868  *
5869  * @details
5870  *
5871  *    Function : FreeInitialUlBWP
5872  *
5873  *    Functionality: Deallocating memory of InitialUlBWP
5874  *
5875  * @params[in] BWP_UplinkDedicated_t *ulBwp
5876  *
5877  * @return void
5878  *
5879  * ****************************************************************/
5880 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5881 {
5882    uint8_t  rSetIdx, rsrcIdx;
5883    SRS_Config_t   *srsCfg = NULLP;
5884    PUSCH_Config_t *puschCfg = NULLP;
5885    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5886    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5887    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5888    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5889
5890    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5891
5892    if(ulBwp->pusch_Config)
5893    {
5894       if(ulBwp->pusch_Config->choice.setup)
5895       {
5896          puschCfg=ulBwp->pusch_Config->choice.setup;
5897          if(puschCfg->dataScramblingIdentityPUSCH)
5898          {
5899             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5900             {
5901                FreePuschTimeDomAllocList(puschCfg);
5902                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5903                if(dmrsUlCfg->choice.setup)
5904                {
5905                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5906                   {
5907                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5908                      {
5909                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5910                               sizeof(long));
5911                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5912                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5913                      }
5914                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5915                            sizeof(long));
5916                   }
5917                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5918                }
5919                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5920                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5921             }
5922             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5923          }
5924          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5925       }
5926       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5927
5928       /* Free SRS-Config */
5929       if(ulBwp->srs_Config)
5930       {
5931          if(ulBwp->srs_Config->choice.setup)
5932          {
5933             srsCfg = ulBwp->srs_Config->choice.setup;
5934
5935             /* Free Resource Set to add/mod list */
5936             if(srsCfg->srs_ResourceSetToAddModList)
5937             {
5938                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5939                if(rsrcSetList->list.array)
5940                {
5941                   rSetIdx = 0;
5942
5943                   /* Free SRS resource Id list in this SRS resource set */
5944                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5945                   {
5946                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5947
5948                      if(rsrcIdList->list.array)
5949                      {
5950                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5951                         {
5952                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5953                         }
5954                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5955                      }
5956                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5957                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5958                   }
5959
5960                   /* Free resource type info for this SRS resource set */
5961                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5962                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5963
5964                   /* Free memory for each resource set */
5965                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5966                   {
5967                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5968                   }
5969                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5970                }
5971                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5972                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5973             }
5974
5975             /* Free resource to add/modd list */
5976             if(srsCfg->srs_ResourceToAddModList)
5977             {
5978                resourceList = srsCfg->srs_ResourceToAddModList;
5979                if(resourceList->list.array)
5980                {
5981                   rsrcIdx = 0;
5982                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5983                         sizeof(struct SRS_Resource__transmissionComb__n2));
5984                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5985                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5986
5987                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5988                   {
5989                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5990                   }
5991                   CU_FREE(resourceList->list.array, resourceList->list.size);
5992                }
5993                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5994                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5995             }
5996
5997             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5998          }
5999          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
6000       }
6001    }
6002 }
6003 /*******************************************************************
6004  *
6005  * @brief Frees memory allocated for initialUplinkBWP
6006  *
6007  * @details
6008  *
6009  *    Function : FreeinitialUplinkBWP
6010  *
6011  *    Functionality: Deallocating memory of initialUplinkBWP
6012  *
6013  * @params[in] UplinkConfig_t *ulCfg
6014  *
6015  * @return void
6016  *
6017  *
6018  * ****************************************************************/
6019 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
6020 {
6021    BWP_UplinkDedicated_t *ulBwp=NULLP;
6022    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6023
6024    if(ulCfg->initialUplinkBWP)
6025    {
6026       ulBwp=ulCfg->initialUplinkBWP;
6027       if(ulCfg->firstActiveUplinkBWP_Id)
6028       {
6029          if(ulCfg->pusch_ServingCellConfig)
6030          {
6031             puschCfg=ulCfg->pusch_ServingCellConfig;
6032             if(puschCfg->choice.setup)
6033             {
6034                if(puschCfg->choice.setup->ext1)
6035                {
6036                   CU_FREE(puschCfg->choice.setup->ext1->\
6037                         processingType2Enabled,sizeof(BOOLEAN_t));
6038                   CU_FREE(puschCfg->choice.setup->ext1->\
6039                         maxMIMO_Layers,sizeof(long));
6040                   CU_FREE(puschCfg->choice.setup->ext1, \
6041                         sizeof(struct PUSCH_ServingCellConfig__ext1));
6042                }
6043                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6044             }
6045             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6046          }
6047          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6048       }
6049       FreeInitialUlBWP(ulBwp);
6050       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6051    }
6052 }
6053 /*******************************************************************
6054  *
6055  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6056  *
6057  * @details
6058  *
6059  *    Function : FreeBWPDlDedPdschCfg
6060  *
6061  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6062  *
6063  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6064  *
6065  * @return void
6066  *
6067  *
6068  * ****************************************************************/
6069 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6070 {
6071    struct PDSCH_Config *pdschCfg=NULLP;
6072    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6073    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6074    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6075
6076    if(dlBwp->pdsch_Config->choice.setup)
6077    {
6078       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6079       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6080       {
6081          if(pdschCfg->pdsch_TimeDomainAllocationList)
6082          {
6083             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6084             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6085             {
6086                prbBndlType=&pdschCfg->prb_BundlingType;
6087                CU_FREE(prbBndlType->choice.staticBundling,\
6088                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6089                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6090             }
6091             FreePdschTimeDomAllocList(timeDomAllocList);
6092             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6093                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6094          }
6095          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6096          if(dmrsDlCfg->choice.setup)
6097          {
6098             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6099                   sizeof(long));
6100             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6101          }
6102          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6103                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6104       }
6105       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6106    }
6107 }
6108 /*******************************************************************
6109  *
6110  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6111  *
6112  * @details
6113  *
6114  *    Function : FreeBWPDlDedPdcchCfg
6115  *
6116  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6117  *
6118  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6119  *
6120  * @return void
6121  *
6122  *
6123  * ****************************************************************/
6124 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6125 {
6126    uint8_t idx1=0;
6127    uint8_t idx2=0;
6128    struct PDCCH_Config *pdcchCfg=NULLP;
6129    struct ControlResourceSet *controlRSet=NULLP;
6130    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6131
6132    if(dlBwp->pdcch_Config->choice.setup)
6133    {
6134       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6135       if(pdcchCfg->controlResourceSetToAddModList)
6136       {
6137          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6138          if(controlRSetList->list.array)
6139          {
6140             controlRSet = controlRSetList->list.array[idx2];
6141             if(controlRSet)
6142             {
6143                if(controlRSet->frequencyDomainResources.buf)
6144                {
6145                   if(controlRSet->pdcch_DMRS_ScramblingID)
6146                   {
6147                      if(pdcchCfg->searchSpacesToAddModList)
6148                      {
6149                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6150                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
6151                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6152                      }
6153                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6154                   }
6155                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
6156                         controlRSet->frequencyDomainResources.size);
6157                }
6158             }
6159             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6160             {
6161                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6162             }
6163             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6164          }
6165          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6166                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6167       }
6168       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6169    }
6170 }
6171 /*******************************************************************
6172  *
6173  * @brief Builds RLC Config
6174  *
6175  * @details
6176  *
6177  *    Function : BuildRlcConfig
6178  *
6179  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
6180  *
6181  * @params[in] RLC_Config *rlcConfig
6182  *
6183  * @return ROK     - success
6184  *         RFAILED - failure
6185  *
6186  * ****************************************************************/
6187 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
6188 {
6189    rlcConfig->present = rlcLcCfgDb.rlcMode;
6190
6191    switch(rlcConfig->present)
6192    {
6193       case RLC_Config_PR_am:
6194          {
6195             rlcConfig->choice.am = NULLP;
6196             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6197             if(!rlcConfig->choice.am)
6198             {
6199                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6200                return RFAILED;
6201             }
6202
6203             /* UL */
6204             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
6205             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6206             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
6207             {
6208                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6209                return RFAILED;
6210             }
6211             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
6212             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
6213             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
6214             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
6215             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
6216
6217             /* DL */
6218             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
6219             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6220             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
6221             {
6222                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6223                return RFAILED;
6224             }
6225             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
6226             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
6227             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
6228
6229             break;
6230          }
6231
6232       case RLC_Config_PR_um_Bi_Directional:
6233          {
6234             rlcConfig->choice.um_Bi_Directional = NULLP;
6235             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
6236             if(!rlcConfig->choice.um_Bi_Directional)
6237             {
6238                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6239                return RFAILED;
6240             }
6241
6242             /* UL */
6243             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
6244             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6245             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
6246             {
6247                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6248                return RFAILED;
6249             }
6250             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
6251
6252             /* DL */
6253             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
6254             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6255             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
6256             {
6257                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6258                return RFAILED;
6259             }
6260             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
6261             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
6262             break;
6263          }
6264    }
6265    return ROK;
6266 }
6267
6268 /*******************************************************************
6269  *
6270  * @brief Builds MAC LC Config
6271  *
6272  * @details
6273  *
6274  *    Function : BuildMacLCConfig
6275  *
6276  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
6277  *
6278  * @params[in] struct LogicalChannelConfig macLcConfig
6279  *
6280  * @return ROK     - success
6281  *         RFAILED - failure
6282  *
6283  * ****************************************************************/
6284 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6285 {
6286
6287    macLcConfig->ul_SpecificParameters = NULLP;
6288    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6289    if(!macLcConfig->ul_SpecificParameters)
6290    {
6291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6292       return RFAILED;
6293    }
6294
6295    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6296    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6297    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6298    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6299    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6300    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6301    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6302
6303    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6304    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6305    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6306    {
6307       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6308       return RFAILED;
6309    }
6310    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6311
6312    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6313    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6314    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6315    {
6316       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6317       return RFAILED;
6318    }
6319    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6320
6321    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6322    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6323    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6324
6325    return ROK;
6326 }
6327 /*******************************************************************
6328  *
6329  * @brief Builds RLC Bearer to Add/Mod list
6330  *
6331  * @details
6332  *
6333  *    Function :BuildRlcBearerToAddModList
6334  *
6335  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6336  *
6337  * @params[in] rlc_BearerToAddModList
6338  *
6339  * @return ROK     - success
6340  *         RFAILED - failure
6341  *
6342  * ****************************************************************/
6343 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6344 {
6345    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6346
6347    if(updateAllRbCfg)
6348       elementCnt = ueCb->numSrb + ueCb->numDrb;
6349    else
6350    {
6351       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6352       {
6353          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6354             elementCnt++;
6355       }
6356
6357       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6358       {
6359          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6360             elementCnt++;
6361       }
6362    }
6363
6364    if(!elementCnt)
6365    {
6366       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6367       return ROK;
6368    }
6369    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6370    if(!rlcBearerList)
6371    {
6372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6373       return RFAILED;
6374    }
6375    rlcBearerList->list.count = elementCnt;
6376    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6377
6378    rlcBearerList->list.array = NULLP;
6379    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6380    if(!rlcBearerList->list.array)
6381    {
6382       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6383       return RFAILED;
6384    }
6385
6386    for(idx=0; idx<rlcBearerList->list.count; idx++)
6387    {
6388       rlcBearerList->list.array[idx] = NULLP;
6389       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6390       if(!rlcBearerList->list.array[idx])
6391       {
6392          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6393          return RFAILED;
6394       }
6395    }
6396
6397    idx = 0;
6398
6399    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6400    {
6401       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6402          continue;
6403
6404       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6405
6406       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6407       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6408       {
6409          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6410          return RFAILED;
6411       }
6412
6413       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6414       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6415
6416       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6417       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6418       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6419       if(!rlcBearerList->list.array[idx]->rlc_Config)
6420       {
6421          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6422          return RFAILED;
6423       }
6424
6425       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6426       {
6427          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6428          return RFAILED;
6429       }
6430
6431       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6432       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6433       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6434       {
6435          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6436          return RFAILED;
6437       }
6438
6439       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6440       {
6441          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6442          return RFAILED;
6443       }
6444       idx++;
6445    }
6446
6447    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6448    {
6449       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6450          continue;
6451
6452       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6453
6454       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6455       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6456       {
6457          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6458          return RFAILED;
6459       }
6460
6461       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6462       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6463
6464       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6465       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6466       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6467       if(!rlcBearerList->list.array[idx]->rlc_Config)
6468       {
6469          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6470          return RFAILED;
6471       }
6472
6473       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6474       {
6475          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6476          return RFAILED;
6477       }
6478
6479       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6480       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6481       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6482       {
6483          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6484          return RFAILED;
6485       }
6486
6487       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6488       {
6489          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6490          return RFAILED;
6491       }
6492       idx++;
6493    }
6494    return ROK;
6495 }
6496
6497 /*******************************************************************
6498  *
6499  * @brief Free memory allocated for CellGroupConfig
6500  *
6501  * @details
6502  *
6503  *    Function : FreeMemCellGrpCfg
6504  *
6505  *    Functionality: Deallocating memory of CellGroupConfig
6506  *
6507  * @params[in] pointer to CellGroupConfigRrc_t
6508  *
6509  * @return ROK     - success
6510  *         RFAILED - failure
6511  *
6512  ******************************************************************/
6513 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6514 {
6515    uint8_t idx=0;
6516    SpCellConfig_t *spCellCfg=NULLP;
6517    ServingCellConfig_t *srvCellCfg=NULLP;
6518    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6519    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6520    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6521    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6522    struct RLC_Config *rlcConfig=NULLP;
6523    struct LogicalChannelConfig *macLcConfig=NULLP;
6524    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6525    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6526    struct TAG_Config *tagConfig=NULLP;
6527    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6528    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6529    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6530
6531    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6532    if(rlcBearerList)
6533    {
6534       if(rlcBearerList->list.array)
6535       {
6536          for(idx=0; idx<rlcBearerList->list.count; idx++)
6537          {
6538             if(rlcBearerList->list.array[idx])
6539             {
6540                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6541                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6542                if(rlcConfig)
6543                {
6544                   if(rlcConfig->choice.am)
6545                   {
6546                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6547                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6548                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6549                   }
6550                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6551                }
6552                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6553                if(macLcConfig)
6554                {
6555                   if(macLcConfig->ul_SpecificParameters)
6556                   {
6557                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6558                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6559                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6560                   }
6561                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6562                }
6563                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6564             }
6565          }
6566          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6567       }
6568       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6569    }
6570
6571    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6572    if(macCellGrpCfg)
6573    {
6574       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6575       if(schedulingRequestConfig)
6576       {
6577          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6578          if(schReqList)
6579          {
6580             if(schReqList->list.array)
6581             {
6582                for(idx=0;idx<schReqList->list.count; idx++)
6583                {
6584                   if(schReqList->list.array[idx])
6585                   {
6586                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6587                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6588                   }
6589                }
6590                CU_FREE(schReqList->list.array, schReqList->list.size);
6591             }
6592             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6593                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6594             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6595       }
6596       if(macCellGrpCfg->bsr_Config)
6597       {
6598          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6599       }
6600       tagConfig = macCellGrpCfg->tag_Config;
6601       if(tagConfig)
6602       {
6603          tagList = tagConfig->tag_ToAddModList;
6604          if(tagList)
6605          {
6606             if(tagList->list.array)
6607             {
6608                for(idx=0; idx<tagList->list.count; idx++)
6609                {
6610                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6611                }
6612                CU_FREE(tagList->list.array, tagList->list.size);
6613             }
6614             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6615          }
6616          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6617       }
6618
6619       phrConfig = macCellGrpCfg->phr_Config;
6620       if(phrConfig)
6621       {
6622          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6623          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6624       }
6625
6626       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6627    }
6628
6629    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6630    if(phyCellGrpCfg)
6631    {
6632       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6633       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6634    }
6635
6636    spCellCfg = cellGrpCfg->spCellConfig;
6637    if(spCellCfg)
6638    {
6639       if(spCellCfg->servCellIndex)
6640       {
6641          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6642          {
6643             if(spCellCfg->spCellConfigDedicated)
6644             {
6645                srvCellCfg = spCellCfg->spCellConfigDedicated;
6646                if(srvCellCfg->initialDownlinkBWP)
6647                {
6648                   dlBwp = srvCellCfg->initialDownlinkBWP;
6649                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6650                   {
6651                      if(srvCellCfg->defaultDownlinkBWP_Id)
6652                      {
6653                         if(srvCellCfg->uplinkConfig)
6654                         {
6655                            if(srvCellCfg->pdsch_ServingCellConfig)
6656                            {
6657                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6658                               if(pdschCfg->choice.setup)
6659                               {
6660                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6661                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6662                               }
6663                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6664                                        ServingCellConfig__pdsch_ServingCellConfig));
6665                            }
6666                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6667                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6668                         }
6669                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6670                      }
6671                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6672                   }
6673                   if(dlBwp->pdcch_Config)
6674                   {
6675                      if(dlBwp->pdsch_Config)
6676                      {
6677                         FreeBWPDlDedPdschCfg(dlBwp);
6678                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6679                      }
6680                      FreeBWPDlDedPdcchCfg(dlBwp);
6681                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6682                   }
6683                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6684                }
6685                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6686             }
6687             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6688          }
6689          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6690       }
6691       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6692    }
6693    return ROK;
6694 }
6695
6696 /*******************************************************************
6697  *
6698  * @brief Fills CellGroupConfig
6699  *
6700  * @details
6701  *
6702  *    Function : fillCellGrpCfg
6703  *
6704  *    Functionality: Fills CellGroupConfig
6705  *
6706  * @params[in] pointer to CellGroupConfigRrc_t
6707  *
6708  * @return ROK     - success
6709  *         RFAILED - failure
6710  *
6711  ******************************************************************/
6712
6713 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6714 {
6715    uint8_t               ret = RFAILED;
6716    CellGroupConfigRrc_t  cellGrpCfg;
6717    asn_enc_rval_t        encRetVal;
6718
6719    while(true)
6720    {
6721       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6722
6723       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6724
6725       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6726       {
6727          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6728          break;
6729       }
6730
6731       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6732       cellGrpCfg.mac_CellGroupConfig = NULLP;
6733       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6734       if(!cellGrpCfg.mac_CellGroupConfig)
6735       {
6736          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6737          break;
6738       }
6739       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6740       {
6741          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6742          break;
6743       }
6744
6745       cellGrpCfg.physicalCellGroupConfig = NULLP;
6746       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6747       if(!cellGrpCfg.physicalCellGroupConfig)
6748       {
6749          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6750          break;
6751       }
6752       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6753       {
6754          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6755          break;
6756       }
6757
6758       cellGrpCfg.spCellConfig = NULLP;
6759       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6760       if(!cellGrpCfg.spCellConfig)
6761       {
6762          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6763          break;
6764       }
6765       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6766       {
6767          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6768          break;
6769       }
6770
6771       cellGrpCfg.sCellToAddModList = NULLP;
6772       cellGrpCfg.sCellToReleaseList = NULLP;
6773       cellGrpCfg.ext1 = NULLP;
6774
6775       /* encode cellGrpCfg into duToCuRrcContainer */
6776       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6777       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6778       encBufSize = 0;
6779       encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6780       /* Encode results */
6781       if(encRetVal.encoded == ENCODE_FAIL)
6782       {
6783          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6784                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6785          break;
6786       }
6787       else
6788       {
6789          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6790          for(int i=0; i< encBufSize; i++)
6791          {
6792             DU_LOG("%x",encBuf[i]);
6793          }
6794       }
6795
6796       cellGrp->size = encBufSize;
6797       CU_ALLOC(cellGrp->buf, cellGrp->size);
6798       if(!cellGrp->buf)
6799       {
6800          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6801          break;
6802       }
6803       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6804       ret = ROK;
6805       break;
6806    }
6807    FreeMemCellGrpCfg(&cellGrpCfg);
6808    return ret;
6809 }
6810
6811 /*******************************************************************
6812  *
6813  * @brief Free UE Capability RAT container
6814  *
6815  * @details
6816  *
6817  *    Function : freeUeCapRatCont
6818  *
6819  *    Functionality:
6820  *       Free UE Capability RAT conatiner
6821  *
6822  * @params[in]
6823  * @return ROK     - success
6824  *         RFAILED - failure
6825  *
6826  * ****************************************************************/
6827 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6828 {
6829    uint8_t idx;
6830    FeatureSets_t *featureSets;
6831
6832    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6833    {
6834       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6835       {
6836          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6837             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6838       }
6839       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6840    }
6841
6842    if(ueNrCap->featureSets)
6843    {
6844       featureSets = ueNrCap->featureSets;
6845       if(featureSets->featureSetsDownlinkPerCC)
6846       {
6847          if(featureSets->featureSetsDownlinkPerCC->list.array)
6848          {
6849             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6850             {
6851                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6852                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6853                         sizeof(ModulationOrder_t));
6854                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6855             }
6856             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6857          }
6858          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6859       }
6860
6861       if(featureSets->featureSetsUplinkPerCC)
6862       {
6863          if(featureSets->featureSetsUplinkPerCC->list.array)
6864          {
6865             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6866             {
6867                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6868                {
6869                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6870                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6871                          sizeof(ModulationOrder_t));
6872                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6873                }
6874             }
6875             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6876          }
6877          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6878       }
6879       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6880    }
6881 }
6882
6883 /*******************************************************************
6884  *
6885  * @brief Free UE capability RAT container list
6886  *
6887  * @details
6888  *
6889  *    Function : freeUeCapRatContList
6890  *
6891  *    Functionality: Free UE capability RAT container list
6892  *
6893  * @params[in]
6894  * @return ROK     - success
6895  *         RFAILED - failure
6896  *
6897  * ****************************************************************/
6898 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6899 {
6900    uint8_t idx;
6901    if(ueCapablityList->list.array)
6902    {
6903       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6904       {
6905          if(ueCapablityList->list.array[idx])
6906             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6907       }
6908       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6909    }
6910 }
6911
6912 /*******************************************************************
6913  *
6914  * @brief Free Handover preparation information
6915  *
6916  * @details
6917  *
6918  *    Function : freeHOPreparationInfo
6919  *
6920  *    Functionality: Free Handover preparation information
6921  *
6922  * @params[in]
6923  * @return ROK     - success
6924  *         RFAILED - failure
6925  *
6926  * ****************************************************************/
6927 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6928 {
6929    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6930
6931    if(hoPrep->criticalExtensions.choice.c1)
6932    {
6933       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6934       {
6935          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6936          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6937          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6938                sizeof(HandoverPreparationInformationRrc_IEs_t));
6939       }
6940       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6941    }
6942 }
6943
6944 /*******************************************************************
6945  *
6946  * @brief Fill feature sets
6947  *
6948  * @details
6949  *
6950  *    Function : fillFeatureSets
6951  *
6952  *    Functionality: Fill feature sets
6953  *
6954  * @params[in]
6955  * @return ROK     - success
6956  *         RFAILED - failure
6957  *
6958  * ****************************************************************/
6959 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6960 {
6961    uint8_t idx, elementCnt;
6962
6963    featureSets->featureSetsDownlink = NULLP;
6964    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6965    if(!featureSets->featureSetsDownlinkPerCC)
6966    {
6967       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6968       return RFAILED;
6969    }
6970
6971    elementCnt = 1;
6972    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6973    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6974    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6975    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6976    {
6977       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6978       return RFAILED;
6979    }
6980
6981    for(idx = 0; idx < elementCnt; idx++)
6982    {
6983       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6984       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6985       {
6986          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6987          return RFAILED;
6988       }
6989    }
6990
6991    idx = 0;
6992    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6993    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6994    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6995    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6996    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6997
6998    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6999    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
7000    {
7001       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7002       return RFAILED;
7003    }
7004    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
7005
7006    featureSets->featureSetsUplink = NULLP;
7007    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
7008    if(!featureSets->featureSetsUplinkPerCC)
7009    {
7010       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7011       return RFAILED;
7012    }
7013
7014    elementCnt = 1;
7015    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
7016    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
7017    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
7018    if(!featureSets->featureSetsUplinkPerCC->list.array)
7019    {
7020       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7021       return RFAILED;
7022    }
7023
7024    for(idx = 0; idx < elementCnt; idx++)
7025    {
7026       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
7027       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
7028       {
7029          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7030          return RFAILED;
7031       }
7032    }
7033
7034    idx = 0;
7035    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
7036    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
7037    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
7038    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
7039    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
7040    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
7041
7042    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
7043    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
7044    {
7045       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7046       return RFAILED;
7047    }
7048    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
7049
7050    return ROK;
7051 }
7052
7053 /*******************************************************************
7054  *
7055  * @brief Fill UE capability RAT container
7056  *
7057  * @details
7058  *
7059  *    Function : fillUeCapRatCont
7060  *
7061  *    Functionality: Fill UE capability RAT container
7062  *
7063  * @params[in] UE Capability RAT container buffer
7064  * @return ROK     - success
7065  *         RFAILED - failure
7066  *
7067  * ****************************************************************/
7068 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
7069 {
7070    uint8_t             ret = ROK;
7071    uint8_t             idx, elementCnt;
7072    asn_enc_rval_t      encRetVal;
7073    UE_NR_Capability_t  ueNrCap;
7074
7075    while(true)
7076    {
7077       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
7078
7079       /* Filling PDCP parameters */
7080       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
7081       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
7082       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
7083       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
7084       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
7085       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
7086       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
7087       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
7088       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
7089       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
7090       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
7091       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
7092       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
7093       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
7094       ueNrCap.pdcp_Parameters.shortSN = NULLP;
7095       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
7096       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
7097
7098       ueNrCap.rlc_Parameters = NULLP;
7099       ueNrCap.mac_Parameters = NULLP;
7100
7101       /* Filling PHY parameters */
7102       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
7103       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
7104       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
7105       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
7106       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
7107
7108       /* Filling RF parameters */
7109       elementCnt = 1;
7110       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
7111       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
7112       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
7113       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
7114       {
7115          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
7116          ret = RFAILED;
7117          break;
7118       }
7119
7120       for(idx = 0; idx < elementCnt; idx++)
7121       {
7122          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
7123          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
7124          {
7125             ret = RFAILED;
7126             break;
7127          }
7128       }
7129       if(ret == RFAILED)
7130          break;
7131
7132       idx = 0;
7133       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
7134       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
7135       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
7136
7137       ueNrCap.measAndMobParameters = NULLP;
7138       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
7139       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
7140       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
7141       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
7142       ueNrCap.featureSets = NULLP;
7143
7144       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
7145       if(!ueNrCap.featureSets)
7146       {
7147          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
7148          ret = RFAILED;
7149          break;
7150       }
7151
7152       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
7153       {
7154          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
7155          ret = RFAILED;
7156          break;
7157       }
7158
7159       ueNrCap.featureSetCombinations = NULLP;
7160       ueNrCap.lateNonCriticalExtension = NULLP;
7161       ueNrCap.nonCriticalExtension = NULLP;
7162
7163       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7164       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
7165       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7166       encBufSize = 0;
7167       encRetVal = uper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
7168
7169       /* Encode results */
7170       if(encRetVal.encoded == ENCODE_FAIL)
7171       {
7172          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7173             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7174          break;
7175       }
7176       else
7177       {
7178          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7179          for(int i=0; i< encBufSize; i++)
7180          {
7181             DU_LOG("%x",encBuf[i]);
7182          }
7183       }
7184
7185       ueCapRatContBuf->size = encBufSize;
7186       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
7187       if(!ueCapRatContBuf->buf)
7188       {
7189          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7190          break;
7191       }
7192       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
7193       ret = ROK;
7194       break;
7195    }
7196    freeUeCapRatCont(&ueNrCap);
7197    return ROK;
7198 }
7199
7200 /*******************************************************************
7201  *
7202  * @brief Fill UE Capability RAT container list
7203  *
7204  * @details
7205  *
7206  *    Function : fillUeCapRatContList
7207  *
7208  *    Functionality: Fill UE Capability RAT container list
7209
7210  *
7211  * @params[in] UE capability RAT container list
7212  * @return ROK     - success
7213  *         RFAILED - failure
7214  *
7215  * ****************************************************************/
7216 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
7217 {
7218     uint8_t          ret = RFAILED;
7219     uint8_t          idx, elementCnt;
7220
7221     while(true)
7222     {
7223        elementCnt = 1;
7224        ueCapablityList->list.count = elementCnt;
7225        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
7226
7227        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
7228        if(!ueCapablityList->list.array)
7229        {
7230           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7231           ret = RFAILED;
7232           break;
7233        }
7234
7235        for(idx=0; idx<elementCnt; idx++)
7236        {
7237           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
7238           if(ueCapablityList->list.array[idx] == NULLP)
7239           {
7240              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7241              ret = RFAILED;
7242              break;
7243           }
7244        }
7245        idx = 0;
7246        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
7247        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
7248        {
7249           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
7250           ret = RFAILED;
7251           break;
7252        }
7253
7254        ret = ROK;
7255        break;
7256     }
7257     return ret;
7258 }
7259
7260 /*******************************************************************
7261  *
7262  * @brief Fill UE Capability RAT container list octet string
7263  *
7264  * @details
7265  *
7266  *    Function : fillUeCapRatContListBuf
7267  *
7268  *    Functionality: Fill UE Capability RAT container list octet string
7269
7270  *
7271  * @params[in] UE capability RAT container list buffer
7272  * @return ROK     - success
7273  *         RFAILED - failure
7274  *
7275  * ****************************************************************/
7276 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
7277 {
7278    uint8_t          ret = RFAILED;
7279    asn_enc_rval_t   encRetVal;
7280    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7281
7282    while(true)
7283    {
7284       ret = fillUeCapRatContList(&ueCapablityList);
7285       if(ret != ROK)
7286       {
7287          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7288          break;
7289       }
7290
7291       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7292       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7293       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7294       encBufSize = 0;
7295       encRetVal = uper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7296             &ueCapablityList, PrepFinalEncBuf, encBuf);
7297
7298       /* Encode results */
7299       if(encRetVal.encoded == ENCODE_FAIL)
7300       {
7301          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7302                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7303          break;
7304       }
7305       else
7306       {
7307          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7308          for(int i=0; i< encBufSize; i++)
7309          {
7310             DU_LOG("%x",encBuf[i]);
7311          }
7312       }
7313
7314       ueCapablityListBuf->size = encBufSize;
7315       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7316       if(!ueCapablityListBuf->buf)
7317       {
7318          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7319          break;
7320       }
7321       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7322       ret = ROK;
7323       break;
7324    }
7325    freeUeCapRatContList(&ueCapablityList);
7326    return ret;
7327 }
7328
7329 /*******************************************************************
7330  *
7331  * @brief Free Measurement Timing Configuration
7332  *
7333  * @details
7334  *
7335  *    Function : freeMeasuementTimingConfig
7336  *
7337  *    Functionality: Free Measurement Timing Configuration
7338  *
7339  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7340  * @return void
7341  *
7342  * ****************************************************************/
7343 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7344 {
7345    uint8_t measCfgIdx;
7346    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7347    MeasTiming_t *measTiming = NULLP;
7348
7349    if(measTimingConfig.criticalExtensions.choice.c1)
7350    {
7351       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7352       {
7353          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7354          if(measTimingCfg->measTiming)
7355          {
7356             if(measTimingCfg->measTiming->list.array)
7357             {
7358                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7359                {
7360                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7361                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7362                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7363                }
7364                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7365             }
7366             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7367          }
7368          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7369       }
7370       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7371    }
7372 }
7373
7374 /*******************************************************************
7375  *
7376  * @brief Fill Measurement Timing Configuration
7377  *
7378  * @details
7379  *
7380  *    Function : fillMeasTimingCfg
7381  *
7382  *    Functionality: Fill Measurement Timing Configuration
7383  *
7384  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7385  * @return ROK     - success
7386  *         RFAILED - failure
7387  *
7388  * ****************************************************************/
7389 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7390 {
7391    uint8_t elementCnt = 0;
7392    uint8_t measCfgIdx = 0;
7393    MeasTiming_t *measTiming;
7394    SSB_MTC_t *smtc;
7395
7396    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7397    if(!measTimingCfg->measTiming)
7398    {
7399       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7400       return RFAILED;
7401    }
7402
7403    elementCnt = 1;
7404    measTimingCfg->measTiming->list.count = elementCnt;
7405    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7406    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7407    if(!measTimingCfg->measTiming->list.array)
7408    {
7409       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7410       return RFAILED;
7411    }
7412
7413    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7414    {
7415       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7416       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7417       {
7418          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7419          return RFAILED;
7420       }
7421    }
7422
7423    measCfgIdx = 0;
7424    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7425    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7426    if(!measTiming->frequencyAndTiming)
7427    {
7428       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7429       return RFAILED;
7430    }
7431
7432    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7433    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7434
7435    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7436    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7437    smtc->periodicityAndOffset.choice.sf20 = 0;
7438    smtc->duration = SSB_MTC__duration_sf1;
7439    return ROK;
7440 }
7441
7442 /*******************************************************************
7443  *
7444  * @brief Fill Measurement Timing Configuration Octet string
7445  *
7446  * @details
7447  *
7448  *    Function : fillMeasConfigBuf
7449  *
7450  *    Functionality: Fill Measurement Timing Configuration Octet string
7451
7452  *
7453  * @params[in] MeasConfig_t *measConfgBuf
7454  * @return ROK     - success
7455  *         RFAILED - failure
7456  *
7457  * ****************************************************************/
7458 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7459 {
7460    uint8_t          ret = RFAILED;
7461    asn_enc_rval_t   encRetVal;
7462    MeasurementTimingConfigurationRrc_t measTimingConfig;
7463
7464    while(true)
7465    {
7466       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7467       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7468       if(!measTimingConfig.criticalExtensions.choice.c1)
7469       {
7470          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7471          return RFAILED;
7472       }
7473       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7474
7475       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7476       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7477       {
7478          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7479          return RFAILED;
7480       }
7481
7482       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7483       if(ret != ROK)
7484       {
7485          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7486          break;
7487       }
7488
7489       /* Encode measurement timing configuration into octet string */
7490       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7491       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7492       encBufSize = 0;
7493       encRetVal = uper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7494
7495       /* Encode results */
7496       if(encRetVal.encoded == ENCODE_FAIL)
7497       {
7498          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7499                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7500          break;
7501       }
7502       else
7503       {
7504          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7505          for(int i=0; i< encBufSize; i++)
7506          {
7507             DU_LOG("%x",encBuf[i]);
7508          }
7509       }
7510
7511       measTimingConfigBuf->size = encBufSize;
7512       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7513       if(!measTimingConfigBuf->buf)
7514       {
7515          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7516          break;
7517       }
7518       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7519       ret = ROK;
7520       break;
7521    }
7522    freeMeasuementTimingConfig(measTimingConfig);
7523    return ret;
7524 }
7525
7526 /******************************************************************
7527  *
7528  * @brief Free RRC reconfiguration non-critical extension
7529  *
7530  * @details
7531  *
7532  *    Function : freeRrcReconfigNonCriticalExt
7533  *
7534  *    Functionality: Free RRC reconfiguration non-critical extension
7535  *
7536  * @params[in] RRC reconfiguration IE
7537  * @return void
7538  *
7539  * ****************************************************************/
7540 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7541 {
7542    if(rrcRecfg->masterCellGroup)
7543    {
7544       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7545    }
7546 }
7547
7548 /******************************************************************
7549  *
7550  * @brief Free measurement object addmod list
7551  *
7552  * @details
7553  *
7554  *    Function : freeMeasObjToAddModList
7555  *
7556  *    Functionality: Free measurement object add mod list
7557  *
7558  * @params[in] Measurement object add/mod list
7559  * @return void
7560  *
7561  * ****************************************************************/
7562 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7563 {
7564    uint8_t objIdx;
7565    MeasObjectNR_t *measObject;
7566
7567    if(measObjList->list.array)
7568    {
7569       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7570       {
7571          if(measObjList->list.array[objIdx])
7572          {
7573             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7574             {
7575                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7576                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7577                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7578                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7579                if(measObject->absThreshSS_BlocksConsolidation)
7580                {
7581                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7582                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7583                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7584                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7585                }
7586                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7587                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7588                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7589                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7590                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7591             }
7592             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7593          }
7594       }
7595       CU_FREE(measObjList->list.array, measObjList->list.size);
7596    }
7597 }
7598
7599 /******************************************************************
7600  *
7601  * @brief Free report config add mod list
7602  *
7603  * @details
7604  *
7605  *    Function : freeReportCfgToAddModList
7606  *
7607  *    Functionality: Free report config add mod list
7608  *
7609  * @params[in] Report config list
7610  * @return void
7611  *
7612  * ****************************************************************/
7613 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7614 {
7615    uint8_t reportCfgIdx;
7616    ReportConfigToAddMod_t *reportCfg;
7617    ReportConfigNR_t *reportCfgNr;
7618    EventTriggerConfig_t *eventTriggCfg;
7619
7620    if(reportCfgList->list.array)
7621    {
7622       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7623       {
7624          if(reportCfgList->list.array[reportCfgIdx])
7625          {
7626             reportCfg = reportCfgList->list.array[reportCfgIdx];
7627             if(reportCfg->reportConfig.choice.reportConfigNR)
7628             {
7629                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7630                if(reportCfgNr->reportType.choice.eventTriggered)
7631                {
7632                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7633                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7634                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7635                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7636                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7637                }
7638             }
7639          }
7640          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7641       }
7642       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7643    }
7644 }
7645
7646 /******************************************************************
7647  *
7648  * @brief Free measurement id to add mod list
7649  *
7650  * @details
7651  *
7652  *    Function : freeMeasIdToAddModList
7653  *
7654  *    Functionality: Free measurement id to add mod list
7655  *
7656  * @params[in] Measurement id to add mod list
7657  * @return void
7658  *
7659  * ****************************************************************/
7660 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7661 {
7662    uint8_t measIdIdx;
7663    if(measIdList->list.array)
7664    {
7665       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7666       {
7667          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7668       }
7669       CU_FREE(measIdList->list.array, measIdList->list.size);
7670    }
7671 }
7672
7673 /*******************************************************************
7674  *
7675  * @brief Free quantity config
7676  *
7677  * @details
7678  *
7679  *    Function : freeQunatityConfig
7680  *
7681  *    Functionality: Free quantity config
7682  *
7683  * @params[in] Quantity Config
7684  * @return void
7685  *
7686  * ****************************************************************/
7687 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7688 {
7689    uint8_t quanCfgIdx;
7690    QuantityConfigNR_t *quantityCfgNr;
7691
7692    if(quantityCfg->quantityConfigNR_List)
7693    {
7694       if(quantityCfg->quantityConfigNR_List->list.array)
7695       {
7696          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7697          {
7698             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7699             {
7700                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7701                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7702                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7703                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7704                if(quantityCfgNr->quantityConfigRS_Index)
7705                {
7706                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7707                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7708                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7709                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7710                }
7711                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7712             }
7713          }
7714          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7715       }
7716       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7717    }
7718 }
7719
7720 /******************************************************************
7721  *
7722  * @brief Free measurement Config
7723  *
7724  * @details
7725  *
7726  *    Function : freeMeasConfig
7727  *
7728  *    Functionality: Free measurement config
7729  *
7730  * @params[in] Measurement config
7731  * @return void
7732  *
7733  * ****************************************************************/
7734 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7735 {
7736    if(measConfig->measObjectToAddModList)
7737    {
7738       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7739       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7740    }
7741    if(measConfig->reportConfigToAddModList)
7742    {
7743       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7744       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7745    }
7746    if(measConfig->measIdToAddModList)
7747    {
7748       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7749       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7750    }
7751    if(measConfig->s_MeasureConfig)
7752    {
7753       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7754    }
7755    if(measConfig->quantityConfig)
7756    {
7757       freeQuantityConfig(measConfig->quantityConfig);
7758       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7759    }
7760 }
7761 /******************************************************************
7762  *
7763  * @brief Free DRB to AddMod List
7764  *
7765  * @details
7766  *
7767  *    Function : freeDrbToAddModList
7768  *
7769  *    Functionality: Free SRB to AddMod List
7770  *
7771  * @params[in] SBR to add/mod list
7772  * @return void
7773  *
7774  * ****************************************************************/
7775 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7776 {
7777    uint8_t drbIdx;
7778    if(drbToAddList->list.array)
7779    {
7780       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7781       {
7782          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7783          {
7784             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7785             {
7786                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7787                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7788                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7789                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7790             }
7791             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7792             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7793          }
7794          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7795       }
7796       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7797    }
7798 }
7799
7800 /******************************************************************
7801  *
7802  * @brief Free SRB to AddMod List
7803  *
7804  * @details
7805  *
7806  *    Function : freeSrbToAddModList
7807  *
7808  *    Functionality: Free SRB to AddMod List
7809  *
7810  * @params[in] SBR to add/mod list
7811  * @return void
7812  *
7813  * ****************************************************************/
7814 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7815 {
7816    uint8_t srbIdx;
7817    if(srbToAddList->list.array)
7818    {
7819       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7820       {
7821          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7822          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7823          {
7824             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7825             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7826          }
7827
7828          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7829       }
7830       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7831    }
7832 }
7833
7834 /******************************************************************
7835  *
7836  * @brief Free Radio Bearer Config
7837  *
7838  * @details
7839  *
7840  *    Function : freeRadioBearerConfig
7841  *
7842  *    Functionality: Free Radio Bearer config
7843  *
7844  * @params[in] Radio bearer config
7845  * @return void
7846  *
7847  * ****************************************************************/
7848 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7849 {
7850    if(radioBearerConfig->srb_ToAddModList)
7851    {
7852       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7853       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7854    }
7855    if(radioBearerConfig->drb_ToAddModList)
7856    {
7857       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7858       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7859    }
7860 }
7861
7862 /******************************************************************
7863  *
7864  * @brief Free reconfiguration message
7865  *
7866  * @details
7867  *
7868  *    Function : freeRrcReconfig
7869  *
7870  *    Functionality: Free reconfiguration message
7871  *
7872  * @params[in] RRC Reconfiguration message
7873  * @return void
7874  *
7875  * ****************************************************************/
7876 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7877 {
7878    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7879    {
7880       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7881       {
7882          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7883          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7884       }
7885       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7886       {
7887          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7888          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7889       }
7890       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7891       {
7892          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7893          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7894       }
7895       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7896    }
7897 }
7898
7899 /******************************************************************
7900  *
7901  * @brief Fill SRB To Add Mod list
7902  *
7903  * @details
7904  *
7905  *    Function : fillSrbToAddModList
7906  *
7907  *    Functionality: fill SRB to Add Mod list
7908  *
7909  * @params[in] UE control block
7910  *             SRB to Add/Mod list
7911  * @return ROK     - success
7912  *         RFAILED - failure
7913  *
7914  * ****************************************************************/
7915 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7916 {
7917    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7918
7919    if(updateAllRbCfg)
7920       elementCnt = ueCb->numSrb;
7921    else
7922    {
7923       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7924       {
7925          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7926             elementCnt++;
7927       }
7928    }
7929
7930    if(!elementCnt)
7931    {
7932       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7933       return ROK;
7934    }
7935
7936    srbToAddList->list.count = elementCnt;
7937    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7938
7939    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7940    if(!srbToAddList->list.array)
7941    {
7942       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7943       return RFAILED;
7944    }
7945
7946    srbIdx = 0;
7947    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7948    {
7949       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7950          continue;
7951
7952       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7953       if(!srbToAddList->list.array[srbIdx])
7954       {
7955          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7956          return RFAILED;
7957       }
7958
7959       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7960
7961       /* Reestablish PDCP */
7962       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7963       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7964       {
7965          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7966          return RFAILED;
7967       }
7968       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7969
7970       /* PDCP configuration */
7971       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7972       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7973       {
7974          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7975          return RFAILED;
7976       }
7977
7978       /* Reordering timer */
7979       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7980       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7981       {
7982          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7983          return RFAILED;
7984       }
7985       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7986
7987       srbIdx++;
7988    }
7989    return ROK;
7990 }
7991
7992 /******************************************************************
7993  *
7994  * @biief Fill DRBeTo Add Mod list
7995  *
7996  * @details
7997  *
7998  *    Function : fillDrbToAddModList
7999  *
8000  *    Functionality: fill DRB to Add Mod list
8001  *
8002  * @params[in] UE control block
8003  *             DRB to Add/Mod list
8004  * @return ROK     - success
8005  *         RFAILED - failure
8006  *
8007  * ****************************************************************/
8008 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
8009 {
8010    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
8011
8012    if(updateAllRbCfg)
8013       elementCnt = ueCb->numDrb;
8014    else
8015    {
8016       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
8017       {
8018          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
8019             elementCnt++;
8020       }
8021    }
8022
8023    if(!elementCnt)
8024    {
8025       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
8026       return ROK;
8027    }
8028
8029
8030    drbToAddList->list.count = elementCnt;
8031    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
8032
8033    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
8034    if(!drbToAddList->list.array)
8035    {
8036       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
8037       return RFAILED;
8038    }
8039
8040    drbIdx = 0;
8041    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
8042    {
8043       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
8044          continue;
8045
8046       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
8047       if(!drbToAddList->list.array[drbIdx])
8048       {
8049          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
8050          return RFAILED;
8051       }
8052
8053       /* DRB Id */
8054       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
8055
8056       /* PDCP Config */
8057       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
8058       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
8059       {
8060          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
8061          return RFAILED;
8062       }
8063
8064       /* PDCP Config -> DRB */
8065       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
8066       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
8067       {
8068          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
8069          return RFAILED;
8070       }
8071
8072       /* DRB -> Discard Timer */
8073       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
8074       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
8075       {
8076          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
8077          return RFAILED;
8078       }
8079       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
8080
8081       /* UL PDCP SN length */
8082       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
8083       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
8084       {
8085          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
8086          return RFAILED;
8087       }
8088       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
8089
8090       /* DL PDCP SN length */
8091       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
8092       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
8093       {
8094          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
8095          return RFAILED;
8096       }
8097       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
8098
8099       /* Header Compression */
8100       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
8101        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
8102
8103       /* Reordering timer */
8104       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
8105       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
8106       {
8107          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
8108          return RFAILED;
8109       }
8110       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
8111
8112       drbIdx++;
8113    }
8114
8115    return ROK;
8116 }
8117
8118 /******************************************************************
8119  *
8120  * @brief Fill Radio bearer configuration
8121  *
8122  * @details
8123  *
8124  *    Function : fillRadioBearerConfig
8125  *
8126  *    Functionality: Fill Radio bearer configuration
8127  *
8128  * @params[in] UE control block
8129  *             Radio bearer config pointer
8130  * @return ROK     - success
8131  *         RFAILED - failure
8132  *
8133  * ****************************************************************/
8134 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
8135 {
8136    /* SRB To Add/Mod List */
8137    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
8138    if(!radioBearerConfig->srb_ToAddModList)
8139    {
8140       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
8141       return RFAILED;
8142    }
8143    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
8144    {
8145       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
8146       return RFAILED;
8147    }
8148
8149    /* DRB To Add/Mod List */
8150    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
8151    if(!radioBearerConfig->drb_ToAddModList)
8152    {
8153       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
8154       return RFAILED;
8155     }
8156    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
8157    {
8158       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
8159       return RFAILED;
8160    }
8161
8162    return ROK;
8163 }
8164
8165 /*******************************************************************
8166  *
8167  * @brief Fill measurement object to add/mod list
8168  *
8169  * @details
8170  *
8171  *    Function : fillMeasObjToAddModList
8172  *
8173  *    Functionality: Fill measurement object to add/mod list
8174  *
8175  * @params[in] Measurement object to add/mod list
8176  * @return ROK     - success
8177  *         RFAILED - failure
8178  *
8179  * ****************************************************************/
8180 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
8181 {
8182    uint8_t elementCnt, objIdx;
8183    MeasObjectNR_t *measObject;
8184
8185    elementCnt = 1;
8186    measObjList->list.count = elementCnt;
8187    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
8188
8189    CU_ALLOC(measObjList->list.array, measObjList->list.size);
8190    if(!measObjList->list.array)
8191    {
8192       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
8193       return RFAILED;
8194    }
8195
8196    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
8197    {
8198       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
8199       if(!measObjList->list.array[objIdx])
8200       {
8201          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
8202          return RFAILED;
8203       }
8204    }
8205
8206    objIdx = 0;
8207    measObjList->list.array[objIdx]->measObjectId = 1;
8208    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
8209    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
8210    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
8211    {
8212       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
8213       return RFAILED;
8214    }
8215
8216    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
8217
8218    /* SSB frequency */
8219    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
8220    if(!measObject->ssbFrequency)
8221    {
8222       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
8223       return RFAILED;
8224    }
8225    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
8226
8227    /* Subcarrier spacing */
8228    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8229    if(!measObject->ssbSubcarrierSpacing)
8230    {
8231       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
8232       return RFAILED;
8233    }
8234    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
8235
8236    /* SMTC1 */
8237    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
8238    if(!measObject->smtc1)
8239    {
8240       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
8241       return RFAILED;
8242    }
8243    measObject->smtc1->duration = SSB_MTC__duration_sf1;
8244    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
8245    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
8246
8247    /* Absoulute threshold SSB consolidation */
8248    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
8249    if(!measObject->absThreshSS_BlocksConsolidation)
8250    {
8251       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
8252       return RFAILED;
8253    }
8254
8255    /* RSRP threshold */
8256    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
8257    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
8258    {
8259       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
8260       return RFAILED;
8261    }
8262    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
8263
8264    /* RSRQ threshold */
8265    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
8266    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
8267    {
8268       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
8269       return RFAILED;
8270    }
8271    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
8272
8273    /* SINR threshold */
8274    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
8275    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
8276    {
8277       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
8278       return RFAILED;
8279    }
8280    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8281
8282    /* Number of SSBs to average */
8283    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8284    if(!measObject->nrofSS_BlocksToAverage)
8285    {
8286       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8287       return RFAILED;
8288    }
8289    *(measObject->nrofSS_BlocksToAverage) = 2;
8290
8291    /* Quantity Config index */
8292    measObject->quantityConfigIndex = 1;
8293
8294    /* Offset MO */
8295    /* RSRP offset for SSB */
8296    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8297    if(!measObject->offsetMO.rsrpOffsetSSB)
8298    {
8299       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8300       return RFAILED;
8301    }
8302    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8303
8304    /* RSRQ offset for SSB */
8305    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8306    if(!measObject->offsetMO.rsrqOffsetSSB)
8307    {
8308       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8309       return RFAILED;
8310    }
8311    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8312
8313    /* SINR offset for SSB */
8314    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8315    if(!measObject->offsetMO.sinrOffsetSSB)
8316    {
8317       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8318       return RFAILED;
8319    }
8320    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8321
8322    return ROK;
8323 }
8324
8325 /*******************************************************************
8326  *
8327  * @brief Fill Report configuration to Add/mod list
8328  *
8329  * @details
8330  *
8331  *    Function : fillReportCfgToAddModList
8332  *
8333  *    Functionality: Fill Report configuration to Add/mod list
8334  *
8335  * @params[in] Report Config To Add/Mod List
8336  * @return ROK     - success
8337  *         RFAILED - failure
8338  *
8339  * ****************************************************************/
8340 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8341 {
8342    uint8_t elementCnt;
8343    uint8_t reportCfgIdx;
8344    ReportConfigToAddMod_t *reportCfg;
8345    ReportConfigNR_t *reportCfgNr;
8346    EventTriggerConfig_t *eventTriggCfg;
8347
8348    elementCnt = 1;
8349    reportCfgList->list.count = elementCnt;
8350    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8351
8352    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8353    if(!reportCfgList->list.array)
8354    {
8355       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8356       return RFAILED;
8357    }
8358
8359    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8360    {
8361       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8362       if(!reportCfgList->list.array[reportCfgIdx])
8363       {
8364          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8365          return RFAILED;
8366       }
8367    }
8368
8369    reportCfgIdx = 0;
8370    reportCfg = reportCfgList->list.array[reportCfgIdx];
8371    reportCfg->reportConfigId = 1;
8372    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8373
8374    /* Report Configuration for NR */
8375    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8376    if(!reportCfg->reportConfig.choice.reportConfigNR)
8377    {
8378       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8379       return RFAILED;
8380    }
8381    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8382
8383    /* Report Type */
8384    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8385    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8386    if(!reportCfgNr->reportType.choice.eventTriggered)
8387    {
8388       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8389       return RFAILED;
8390    }
8391    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8392
8393    /* Event 3 */
8394    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8395    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8396    if(!eventTriggCfg->eventId.choice.eventA3)
8397    {
8398       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8399       return RFAILED;
8400    }
8401
8402    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8403    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8404    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8405    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8406    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8407    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8408
8409    /* Reference Signal Type */
8410    eventTriggCfg->rsType = NR_RS_Type_ssb;
8411
8412    /* Report Interval */
8413    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8414
8415    /* Report Amount */
8416    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8417
8418    /* Report Quantity cell */
8419    eventTriggCfg->reportQuantityCell.rsrp = true;
8420    eventTriggCfg->reportQuantityCell.rsrq = false;
8421    eventTriggCfg->reportQuantityCell.sinr = false;
8422
8423    /* Maximum reported cells */
8424    eventTriggCfg->maxReportCells = 3;
8425
8426    /* Report qunatity RS Indexes */
8427    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8428    if(!eventTriggCfg->reportQuantityRS_Indexes)
8429    {
8430       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8431       return RFAILED;
8432    }
8433    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8434    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8435    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8436
8437    /* Maximum number of RS indexes to report */
8438    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8439    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8440    {
8441       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8442       return RFAILED;
8443    }
8444    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8445
8446    /* Include Beam measurement */
8447    eventTriggCfg->includeBeamMeasurements = false;
8448
8449    return ROK;
8450 }
8451
8452 /*******************************************************************
8453  *
8454  * @brief Fill measurement Id to add/mod list
8455
8456  * @details
8457  *
8458  *    Function : fillMeasIdToAddModList
8459  *
8460  *    Functionality: Fill measurement Id to add/mod list
8461  *
8462  * @params[in] Measurement Id to add/mod list
8463  * @return ROK     - success
8464  *         RFAILED - failure
8465  *
8466  * ****************************************************************/
8467 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8468 {
8469    uint8_t elementCnt;
8470    uint8_t measIdIdx;
8471
8472    elementCnt = 1;
8473    measIdList->list.count = elementCnt;
8474    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8475
8476    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8477    if(!measIdList->list.array)
8478    {
8479       return RFAILED;
8480    }
8481
8482    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8483    {
8484       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8485       if(!measIdList->list.array[measIdIdx])
8486       {
8487          return RFAILED;
8488       }
8489
8490       measIdIdx=0;
8491       measIdList->list.array[measIdIdx]->measId = 1;
8492       measIdList->list.array[measIdIdx]->measObjectId = 1;
8493       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8494    }
8495    return ROK;
8496 }
8497
8498 /*******************************************************************
8499  *
8500  * @brief Fill s-measurement configuration
8501  *
8502  * @details
8503  *
8504  *    Function : fillSMeasConfig
8505  *
8506  *    Functionality: Fill s-measurement configuration
8507  *
8508  * @params[in] s-Measurement config
8509  * @return ROK     - success
8510  *         RFAILED - failure
8511  *
8512  * ****************************************************************/
8513 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8514 {
8515    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8516    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8517
8518    return ROK;
8519 }
8520
8521 /*******************************************************************
8522  *
8523  * @brief Fill quantity config
8524  *
8525  * @details
8526  *
8527  *    Function : fillQunatityConfig
8528  *
8529  *    Functionality: Fill quantity config
8530  *
8531  * @params[in] Quantity Config
8532  * @return ROK     - success
8533  *         RFAILED - failure
8534  *
8535  * ****************************************************************/
8536 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8537 {
8538    uint8_t elementCnt = 0;
8539    uint8_t quanCfgIdx = 0;
8540    QuantityConfigNR_t *quantityCfgNr;
8541
8542    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8543    if(!quantityCfg->quantityConfigNR_List)
8544    {
8545       return RFAILED;
8546    }
8547
8548    elementCnt = 1;
8549    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8550    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8551
8552    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8553    if(!quantityCfg->quantityConfigNR_List->list.array)
8554    {
8555       return RFAILED;
8556    }
8557
8558    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8559    {
8560       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8561       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8562       {
8563          return RFAILED;
8564       }
8565    }
8566
8567    quanCfgIdx = 0;
8568    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8569
8570    /* Quantity Config of Reference signal */
8571    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8572    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8573    {
8574       return RFAILED;
8575    }
8576    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8577
8578    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8579    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8580    {
8581       return RFAILED;
8582    }
8583    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8584
8585    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8586    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8587    {
8588       return RFAILED;
8589    }
8590    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8591
8592    /* Quantity Config RS index */
8593    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8594    if(!quantityCfgNr->quantityConfigRS_Index)
8595    {
8596       return RFAILED;
8597    }
8598
8599    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8600    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8601    {
8602       return RFAILED;
8603    }
8604    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8605
8606    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8607    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8608    {
8609       return RFAILED;
8610    }
8611    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8612
8613    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8614    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8615    {
8616       return RFAILED;
8617    }
8618    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8619
8620    return ROK;
8621 }
8622
8623 /*******************************************************************
8624  *
8625  * @brief Fill measurement configuration
8626  *
8627  * @details
8628  *
8629  *    Function : fillMeasConfig
8630  *
8631  *    Functionality: Fill measurement configuration
8632  *
8633  * @params[in] Measurement config
8634  * @return ROK     - success
8635  *         RFAILED - failure
8636  *
8637  * ****************************************************************/
8638 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8639 {
8640    /* Measurement object to add/mod list */
8641    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8642    if(!measConfig->measObjectToAddModList)
8643    {
8644       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8645       return RFAILED;
8646    }
8647    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8648    {
8649       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8650       return RFAILED;
8651    }
8652
8653    /* Report Config To add/mod list */
8654    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8655    if(!measConfig->reportConfigToAddModList)
8656    {
8657       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8658       return RFAILED;
8659    }
8660    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8661    {
8662       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8663       return RFAILED;
8664    }
8665
8666    /* Measurement Id to add/mod list */
8667    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8668    if(!measConfig->measIdToAddModList)
8669    {
8670       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8671       return RFAILED;
8672    }
8673    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8674    {
8675       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8676       return RFAILED;
8677    }
8678
8679    /* S-Measurement config */
8680    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8681    if(!measConfig->s_MeasureConfig)
8682    {
8683       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8684       return RFAILED;
8685    }
8686    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8687    {
8688       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8689       return RFAILED;
8690    }
8691
8692    /* Qunatity Config */
8693    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8694    if(!measConfig->quantityConfig)
8695    {
8696       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8697       return RFAILED;
8698    }
8699    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8700    {
8701       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8702       return RFAILED;
8703    }
8704
8705 return ROK;
8706 }
8707
8708 /*******************************************************************
8709  *
8710  * @brief Fill RRC reconfiguration non-critical extension IE
8711  *
8712  * @details
8713  *
8714  *    Function : fillRrcReconfigNonCriticalExt
8715  *
8716  *    Functionality: Fill RRC reconfiguration non-critical extension
8717  *
8718  * @params[in] RRC Reconfig Non-critical extension
8719  * @return ROK     - success
8720  *         RFAILED - failure
8721  *
8722  * ****************************************************************/
8723 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8724 {
8725    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8726    if(!rrcRecfg->masterCellGroup)
8727    {
8728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8729       return RFAILED;
8730    }
8731
8732    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8733    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8734    if(!rrcRecfg->masterCellGroup->buf)
8735    {
8736       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8737       return RFAILED;
8738    }
8739    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8740
8741 #if 0
8742    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8743     * received from DU */
8744    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8745    {
8746       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8747       return RFAILED;
8748    }
8749 #endif
8750
8751    return ROK;
8752 }
8753
8754 /*******************************************************************
8755  *
8756  * @brief Fill RRC reconfiguration structure
8757  *
8758  * @details
8759  *
8760  *    Function : fillRrcReconfig
8761  *
8762  *    Functionality: Fill RRC reconfiguration
8763
8764  *
8765  * @params[in] UE Cb
8766  *             RRC reconfiguration structure
8767  * @return ROK     - success
8768  *         RFAILED - failure
8769  *
8770  * ****************************************************************/
8771 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8772 {
8773    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8774
8775    rrcReconfig->rrc_TransactionIdentifier = 1;
8776    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8777
8778    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8779    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8780    {
8781       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8782       return RFAILED;
8783    }
8784
8785    /* Radio Bearer Configuration */
8786    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8787    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8788    {
8789       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8790       return RFAILED;
8791    }
8792    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8793    {
8794       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8795       return RFAILED;
8796    }
8797
8798    /* Measurement Configuration */
8799    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8800    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8801    {
8802       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8803       return RFAILED;
8804    }
8805    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8806    {
8807       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8808       return RFAILED;
8809    }
8810
8811    /* Non Critical extension */
8812    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8813    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8814    {
8815       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8816       return RFAILED;
8817    }
8818    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8819    {
8820       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8821       return RFAILED;
8822    }
8823    return ROK;
8824 }
8825
8826 /*******************************************************************
8827  *
8828  * @brief Fill RRC reconfiguration Octet string
8829  *
8830  * @details
8831  *
8832  *    Function : fillRrcReconfigBuf
8833  *
8834  *    Functionality: Fill RRC reconfiguration octet string
8835
8836  *
8837  * @params[in] OCTET_STRING_t buffer
8838  * @return ROK     - success
8839  *         RFAILED - failure
8840  *
8841  * ****************************************************************/
8842 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8843 {
8844    uint8_t          ret = RFAILED;
8845    asn_enc_rval_t   encRetVal;
8846    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8847    rrcReconfig = &rrcRecfg;
8848
8849    while(true)
8850    {
8851       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8852       {
8853          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8854          break;
8855       }
8856
8857       /* Encode RRC Reconfiguration */
8858       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8859       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8860       encBufSize = 0;
8861       encRetVal = uper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8862
8863       /* Encode results */
8864       if(encRetVal.encoded == ENCODE_FAIL)
8865       {
8866          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8867                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8868          break;
8869       }
8870       else
8871       {
8872          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8873          for(int i=0; i< encBufSize; i++)
8874          {
8875             DU_LOG("%x",encBuf[i]);
8876          }
8877       }
8878
8879       rrcReconfigBuf->size = encBufSize;
8880       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8881       if(!rrcReconfigBuf->buf)
8882       {
8883          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8884          break;
8885       }
8886       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8887       ret = ROK;
8888       break;
8889    }
8890
8891    freeRrcReconfig(rrcReconfig);
8892    return ret;
8893 }
8894
8895 /*******************************************************************
8896  *
8897  * @brief Fill HO preparation information Octet string
8898  *
8899  * @details
8900  *
8901  *    Function : fillHOPreparationInfoBuf
8902  *
8903  *    Functionality: Fill HO preparation information Octet string
8904
8905  *
8906  * @params[in] HandoverPreparationInformation_t buffer
8907  * @return ROK     - success
8908  *         RFAILED - failure
8909  *
8910  * ****************************************************************/
8911 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8912 {
8913    uint8_t          ret = RFAILED;
8914    asn_enc_rval_t   encRetVal;
8915    HandoverPreparationInformationRrc_t hoPrepInfo;
8916    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8917
8918    while(true)
8919    {
8920
8921       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8922       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8923       if(!hoPrepInfo.criticalExtensions.choice.c1)
8924       {
8925          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8926          break;
8927       }
8928       hoPrepInfo.criticalExtensions.choice.c1->present = \
8929          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8930
8931       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8932          sizeof(HandoverPreparationInformationRrc_IEs_t));
8933       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8934       {
8935          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8936          break;
8937       }
8938       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8939
8940       /* Fill UE Capability RAT container list */
8941       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8942       if(ret != ROK)
8943       {
8944          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8945          break;
8946       }
8947
8948       /* Fill Source config */
8949       hoPrepInfoIe->sourceConfig = NULLP;
8950       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8951       if(!hoPrepInfoIe->sourceConfig)
8952       {
8953          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8954          return RFAILED;
8955       }
8956       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8957
8958       if(ret != ROK)
8959       {
8960          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8961          return RFAILED;
8962       }
8963
8964       hoPrepInfoIe->rrm_Config = NULLP;
8965       hoPrepInfoIe->as_Context = NULLP;
8966       hoPrepInfoIe->nonCriticalExtension = NULLP;
8967
8968       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8969       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8970       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8971       encBufSize = 0;
8972       encRetVal = uper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8973             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8974
8975       /* Encode results */
8976       if(encRetVal.encoded == ENCODE_FAIL)
8977       {
8978          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8979                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8980          break;
8981       }
8982       else
8983       {
8984          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8985          for(int i=0; i< encBufSize; i++)
8986          {
8987             DU_LOG("%x",encBuf[i]);
8988          }
8989       }
8990
8991       hoPrepInfoBuf->size = encBufSize;
8992       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8993       if(!hoPrepInfoBuf->buf)
8994       {
8995          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8996          break;
8997       }
8998       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8999       ret = ROK;
9000       break;
9001    }
9002    freeHOPreparationInfo(&hoPrepInfo);
9003    return ret;
9004 }
9005
9006 /*******************************************************************
9007  *
9008  * @brief Fills CuToDuContainer
9009  *
9010  * @details
9011  *
9012  *    Function : fillCuToDuContainer
9013  *
9014  *    Functionality: Fills CuToDuContainer
9015  *
9016  * @params[in] pointer to CUtoDURRCInformation_t
9017  *
9018  * @return ROK     - success
9019  *         RFAILED - failure
9020  *
9021  ******************************************************************/
9022
9023 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
9024 {
9025    uint8_t elementCnt = 0;
9026    uint8_t ret = ROK;
9027    uint8_t idx;
9028
9029    if((ueCb->state != UE_HANDOVER_IN_PROGRESS) || ((ueCb->state == UE_HANDOVER_IN_PROGRESS) && (ueCb->hoInfo.HOType == Inter_DU_HO)))
9030    {
9031       /* UE Capabulity RAT Container List */
9032       CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9033       if(!rrcMsg->uE_CapabilityRAT_ContainerList)
9034       {
9035          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
9036          return RFAILED;
9037       }
9038       ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
9039    }
9040
9041 #if 0
9042
9043    /* Commenting this because:
9044     * CUToDURRCInformation->MeasConfig contains measurement gap configurations.
9045     * Howeever measurement gap is not supported in our code. Measurement Gap will
9046     * be required if we want to support inter-RAT handover or handover to
9047     * neighbouring cells operating on a different frequency than serving cell.
9048     *
9049     * In case we plan to use this IE in future, following fixes are required:
9050     * As of now, we are filling MeasurementTimingConfigurationRrc_t into rrcMsg->measConfig.
9051     * This is incorrect. We must fill MeasConfigRrc_t in rrcMsg->measConfig.
9052     * MeasurementTimingConfigurationRrc_t should be filled in
9053     * rrcMsg->iE_Extensions->MeasurementTimingConfiguration, if required.
9054     */
9055
9056    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
9057    if(!rrcMsg->measConfig)
9058    {
9059       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
9060       return RFAILED;
9061    }
9062    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
9063 #endif
9064
9065    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9066    {
9067       /* IE extensions */
9068       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9069       if(rrcMsg->iE_Extensions)
9070       {
9071          elementCnt = 1;
9072          rrcMsg->iE_Extensions->list.count = elementCnt;
9073          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
9074
9075          /* Initialize the CUtoDURRCInformation_ExtIEs */
9076          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9077
9078          if(rrcMsg->iE_Extensions->list.array == NULLP)
9079          {
9080             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
9081             ret = RFAILED;
9082          }
9083
9084          for(idx=0; idx<elementCnt; idx++)
9085          {
9086             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
9087             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
9088             {
9089                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
9090                ret = RFAILED;
9091             }
9092          }
9093
9094          idx = 0;
9095 #if 0
9096          /* Cell Group Configuration */
9097          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
9098          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9099          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
9100                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
9101          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
9102          idx++;
9103 #endif
9104          /* Handover Preparation Information */
9105          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
9106          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9107          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
9108                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
9109          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
9110       }
9111    }
9112    return ret;
9113 }
9114 /*******************************************************************
9115  *
9116  * @brief Build the drx cycle
9117  *
9118  * @details
9119  *
9120  *    Function : BuildDrxCycle
9121  *
9122  *    Functionality: Build drx cycle IE
9123  *
9124  * @params[in] pointer to DRXCycle_t
9125  *
9126  * @return ROK     - success
9127  *         RFAILED - failure
9128  *
9129  ******************************************************************/
9130 uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
9131 {
9132    drxCycle->longDRXCycleLength = LongDRXCycleLength_ms80;
9133    CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
9134    if(!drxCycle->shortDRXCycleLength)
9135    {
9136       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleLength");
9137       return RFAILED;
9138    }
9139    *(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
9140
9141    CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
9142    if(!drxCycle->shortDRXCycleTimer)
9143    {
9144       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleTimer");
9145       return RFAILED;
9146    }
9147    *(drxCycle->shortDRXCycleTimer) = 4;
9148    return ROK;
9149 }
9150 /*******************************************************************
9151  *
9152  * @brief Free CuToDuContainer
9153  *
9154  * @details
9155  *
9156  *    Function : FreeCuToDuInfo
9157  *
9158  *    Functionality: Free CuToDuContainer
9159  *
9160  * @params[in] pointer to CUtoDURRCInformation_t
9161  *
9162  * @return ROK     - success
9163  *         RFAILED - failure
9164  *
9165  ******************************************************************/
9166
9167 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9168 {
9169    uint8_t idx, idx2;
9170
9171    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9172    {
9173       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9174          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
9175       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9176    }
9177    if(rrcMsg->iE_Extensions)
9178    {
9179       if(rrcMsg->iE_Extensions->list.array)
9180       {
9181          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
9182          {
9183             if(rrcMsg->iE_Extensions->list.array[idx])
9184             {
9185                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
9186                {
9187                   case ProtocolIE_ID_id_CellGroupConfig:
9188                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9189                      {
9190                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
9191                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
9192
9193                      }
9194                      break;
9195                   default:
9196                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9197                            rrcMsg->iE_Extensions->list.array[idx]->id);
9198                      break;
9199                }
9200             }
9201             break;
9202          }
9203          for(idx2 = 0; idx2 < idx; idx2++)
9204          {
9205             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
9206          }
9207          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9208
9209       }
9210
9211       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9212    }
9213 }
9214 /*******************************************************************
9215  *
9216  * @brief Builds and sends the UE Setup Request
9217  *
9218  * @details
9219  *
9220  *    Function : BuildAndSendUeContextSetupReq
9221  *
9222  *    Functionality: Constructs the UE Setup Request and sends
9223  *                   it to the CU through SCTP.
9224  *
9225  * @params[in]
9226  *
9227  * @return ROK     - success
9228  *         RFAILED - failure
9229  *
9230  * ****************************************************************/
9231 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
9232 {
9233    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
9234    uint8_t   ret= RFAILED, ret1;
9235    uint8_t   elementCnt;
9236    uint8_t   idx, idx1, bufLen, duIdx;
9237    uint32_t  spCellId;
9238    uint32_t  targetDuId;
9239    DuDb      *targetDuDb = NULLP;
9240    F1AP_PDU_t           *f1apMsg = NULLP;
9241    UEContextSetupRequest_t *ueSetReq = NULLP;
9242    asn_enc_rval_t encRetVal;        /* Encoder return value */
9243    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9244
9245    while(true)
9246    {
9247       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
9248
9249       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9250       if(f1apMsg == NULLP)
9251       {
9252          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9253          break;
9254       }
9255
9256       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9257       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9258       if(f1apMsg->choice.initiatingMessage == NULLP)
9259       {
9260          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
9261          break;
9262       }
9263
9264       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
9265       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9266       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
9267
9268       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9269
9270       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9271          elementCnt = 7;
9272       else
9273       {
9274 #ifdef NR_DRX
9275          elementCnt = 12;
9276 #else
9277          elementCnt = 11;
9278 #endif
9279       }
9280       ueSetReq->protocolIEs.list.count = elementCnt;
9281       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
9282
9283       /* Initialize the UESetup members */
9284       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
9285
9286       if(ueSetReq->protocolIEs.list.array == NULLP)
9287       {
9288          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
9289          break;
9290       }
9291
9292       for(idx1=0; idx1<elementCnt; idx1++)
9293       {
9294          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
9295          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
9296          {
9297             break;
9298          }
9299       }
9300
9301       idx = 0;
9302
9303       /*GNB CU UE F1AP ID*/
9304       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9305       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9306       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
9307       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
9308
9309       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9310       {
9311          /*GNB DU UE F1AP ID*/
9312          idx++;
9313          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9314          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9315          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
9316          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
9317       }
9318
9319       /*Special Cell ID*/
9320       idx++;
9321       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
9322       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9323       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
9324
9325       /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
9326       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9327       {
9328          if(ueCb->hoInfo.HOType == Inter_DU_HO)
9329             targetDuId = ueCb->hoInfo.tgtNodeId;
9330          else
9331             targetDuId = duId;
9332
9333          SEARCH_DU_DB(duIdx, targetDuId, targetDuDb);
9334          /* Since we are supporting only one cell per DU, accessing 0th index to
9335           * get target cell info */
9336          spCellId = targetDuDb->cellCb[0].nrCellId;
9337       }
9338       else
9339          spCellId = ueCb->cellCb->nrCellId;
9340
9341       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
9342       if(Nrcgiret != ROK)
9343       {
9344          break;
9345       }
9346
9347       /*Served Cell Index*/
9348       idx++;
9349       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9350       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9351       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9352       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9353
9354       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9355       {
9356          /*CellULConfigured*/
9357          idx++;
9358          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9359          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9360          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9361          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9362       }
9363
9364       /*CUtoDURRCContainer*/
9365       idx++;
9366       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9367       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9368       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9369       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9370       {
9371          break;
9372       }
9373
9374       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9375       {
9376          /*Drx cycle*/
9377 #ifdef NR_DRX
9378          idx++;
9379          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_DRXCycle;
9380          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9381          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
9382          if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
9383          {
9384             DU_LOG("\nERROR  -->  F1AP : Failed to build drx cycle");
9385             break;
9386          }
9387 #endif
9388          /*Special Cells to be SetupList*/
9389          idx++;
9390          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9391          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9392          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9393          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9394          if(SplCellListret != ROK)
9395          {
9396             break;
9397          }
9398       }
9399
9400       /*SRBs To Be Setup List*/
9401       idx++;
9402       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9403       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9404       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9405       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9406       if(SrbSetupret != ROK)
9407       {
9408          break;
9409       }
9410
9411       /*DRBs to Be Setup List*/
9412       idx++;
9413       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9414       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9415       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9416       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9417       if(ret1 != ROK)
9418       {
9419          break;
9420       }
9421
9422       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9423       {
9424          /* RRC delivery status request */
9425          idx++;
9426          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9427          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9428          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9429          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9430       }
9431
9432       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9433       idx++;
9434       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9435       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9436       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9437
9438       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9439       bufLen = 4;
9440       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9441       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9442             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9443       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9444       {
9445          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9446          break;
9447       }
9448       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9449       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9450
9451       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9452
9453       /* Encode the F1SetupRequest type as APER */
9454       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9455       encBufSize = 0;
9456       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9457
9458       /* Encode results */
9459       if(encRetVal.encoded == ENCODE_FAIL)
9460       {
9461          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9462                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9463          break;
9464       }
9465       else
9466       {
9467          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9468          for(int i=0; i< encBufSize; i++)
9469          {
9470             DU_LOG("%x",encBuf[i]);
9471          }
9472       }
9473
9474       /* Sending  msg  */
9475       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9476       {
9477          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9478          break;
9479       }
9480       ret = ROK;
9481       break;
9482    }
9483    FreeUeContextSetupReq(f1apMsg);
9484
9485    return ret;
9486 }/* End of BuildAndSendUeContextSetupReq*/
9487
9488 /**********************************************************************
9489  * @brief Function to extractTeId received in UE context setup Response
9490  *
9491  * @details
9492  *
9493  *    Function : extractTeId
9494  *
9495  *    Functionality:
9496  *         - Function to extract TeId
9497  *
9498  * @params[in]
9499  * @return ROK     - success
9500  *         RFAILED - failure
9501  *
9502  **********************************************************************/
9503 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9504 {
9505    uint8_t arrIdx = 0;
9506    uint32_t teId = 0;
9507    GTPTunnel_t *gtpDl = NULLP;
9508
9509    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9510    {
9511       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9512       {
9513          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9514          {
9515             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9516             if(gtpDl->gTP_TEID.size > 0)
9517             {
9518                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9519             }
9520             else
9521                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9522             return(teId);
9523          }
9524       }
9525    }
9526    return teId;
9527 }
9528
9529 /****************************************************************
9530  * @brief Function to add Drb tunnels
9531  *
9532  * @details
9533  *
9534  *    Function : addDrbTunnels
9535  *
9536  *    Functionality:
9537  *         - Function to add Drb tunnels
9538  *
9539  * @params[in]
9540  * @return ROK     - success
9541  *         RFAILED - failure
9542  *
9543  * ****************************************************************/
9544 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9545 {
9546    uint8_t ret = ROK;
9547    EgtpTnlEvt tnlEvt;
9548
9549    if(teId > MAX_TEID || teId < MIN_TEID)
9550    {
9551       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9552    }
9553    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9554    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9555    tnlEvt.lclTeid = teId;
9556    tnlEvt.remTeid = teId;
9557    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9558    if(ret != ROK)
9559    {
9560       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9561    }
9562    return ROK;
9563 }
9564
9565 /****************************************************************
9566  * @brief Function to process Drb Setup List
9567  *
9568  * @details
9569  *
9570  *    Function : procDrbSetupList
9571  *
9572  *    Functionality:
9573  *         - Function to process DRB Setup List
9574  *
9575  * @params[in]
9576  * @return ROK     - success
9577  *         RFAILED - failure
9578  *
9579  * ****************************************************************/
9580 uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
9581 {
9582    uint8_t arrIdx = 0, drbIdx = 0;
9583    uint32_t teId = 0;
9584    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9585
9586    if(drbSetupList != NULLP)
9587    {
9588       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9589       {
9590          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9591          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9592          {
9593             /* extracting teId */
9594             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9595             if(teId > 0)
9596             {
9597                if(addDrbTunnels(duId, teId)== ROK)
9598                {
9599                   DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9600                }
9601                /* As per Spec 38.473, in UE COntext Response, Tunnel information
9602                 * are sent to CU for setting up of Tunnels in DL direction.
9603                 * Search for DRB ID in CU databse */
9604                for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
9605                {
9606                   if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
9607                   {
9608                      fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
9609                      break;
9610                   }
9611                }
9612             }
9613             else
9614                return RFAILED;
9615          }
9616       }
9617    }
9618    return ROK;
9619 }
9620
9621 /****************************************************************
9622  * @brief Function to process Ue Context Setup Response
9623  *
9624  * @details
9625  *
9626  *    Function : procUeContextSetupResponse
9627  *
9628  *    Functionality:
9629  *         - Function to process Ue Context Setup Response
9630  *
9631  * @params[in]
9632  * @return ROK     - success
9633  *         RFAILED - failure
9634  *
9635  * ****************************************************************/
9636 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg, char *recvBuf, MsgLen recvBufLen)
9637 {
9638    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9639    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9640    DuDb *duDb = NULLP;
9641    CuUeCb *ueCb = NULLP;
9642    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9643    OCTET_STRING_t *duToCuRrcContainer;
9644
9645    SEARCH_DU_DB(duIdx, duId, duDb);
9646    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9647
9648    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9649    {
9650       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9651       {
9652           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9653              {
9654                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9655                break;
9656              }
9657           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9658              {
9659                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9660                 ueCb = &duDb->ueCb[duUeF1apId-1];
9661                 /* If ue context is not present in du db, then create UE context
9662                  * here. This flow is hit in case of UE handover where UE
9663                  * context is created before UE performs RACH on target DU */
9664                 if(ueCb->gnbDuUeF1apId == 0)
9665                 {
9666                    /* Creating UE context in target DU */
9667                    memset(ueCb, 0, sizeof(CuUeCb));
9668
9669                    /* Check if UE is under Inter-CU handover */
9670                    if(duDb->tempUeCtxtInHo && (duDb->tempUeCtxtInHo->gnbCuUeF1apId == cuUeF1apId))
9671                    {
9672                       memcpy(ueCb, duDb->tempUeCtxtInHo, sizeof(CuUeCb));
9673                       ueCb->gnbDuUeF1apId = duUeF1apId;
9674                       CU_FREE(duDb->tempUeCtxtInHo, sizeof(CuUeCb));
9675                    }
9676                    else
9677                    {
9678                       /* In case of Inter DU Handover */
9679                       ueCb->cellCb = &duDb->cellCb[0];
9680                       ueCb->gnbDuUeF1apId = duUeF1apId;
9681                       ueCb->gnbCuUeF1apId = cuUeF1apId;
9682                       ueCb->state = UE_HANDOVER_IN_PROGRESS;
9683                       ueCb->hoInfo.HOType = Inter_DU_HO;
9684                       ueCb->hoInfo.tgtNodeId = duId;
9685                    }
9686                    (duDb->numUe)++;
9687
9688                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9689                    ueCb->cellCb->numUe++;
9690                 }
9691                 break;
9692              }
9693           case ProtocolIE_ID_id_C_RNTI:
9694              {
9695                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9696                 break;
9697              }
9698           case ProtocolIE_ID_id_DRBs_Setup_List:
9699              {
9700                 /* Adding Tunnels for successful DRB */
9701                 procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9702                 break;
9703              }
9704          case ProtocolIE_ID_id_DUtoCURRCInformation:
9705              {
9706                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9707                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9708                    DUtoCURRCInformation.cellGroupConfig;
9709                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9710                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9711                 {
9712                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9713                    return RFAILED;
9714                 }
9715                 break;
9716              }
9717       }
9718    }
9719
9720    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9721    {
9722       ueCb->f1apMsgDb.dlRrcMsgCount++;
9723       rrcMsgType = setDlRRCMsgType(ueCb);
9724
9725       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9726       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9727       {
9728          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9729          return RFAILED;
9730       }
9731    }
9732    else
9733    {
9734       if(ueCb->hoInfo.HOType == Inter_DU_HO)
9735       {
9736          /* If the UE is in Inter-DU handover, UE context modification request is to be sent to
9737           * source DU once UE context setup response is received from target DU */
9738
9739          DuDb *srcDuDb = NULLP;
9740          CuUeCb *ueCbInSrcDu = NULLP;
9741
9742          /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9743           * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9744          for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9745          {
9746             /* UE context setup response is received from target DU. Search all
9747              * DUs to find source DU except this target DU Id.*/
9748             if(cuCb.duInfo[duIdx].duId != duId)
9749             {
9750                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9751                {
9752                   /* Check following:
9753                    * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9754                    * received in UE context setup response since CU UE F1AP ID does not
9755                    * change for UE in handover.
9756                    * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9757                    */
9758                   if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9759                         (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9760                   {
9761                      srcDuDb = &cuCb.duInfo[duIdx];
9762                      ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9763
9764                      /* Store source DU info in the new UE context created in
9765                       * tareget DU */
9766                      ueCb->hoInfo.srcNodeId = srcDuDb->duId;
9767
9768                      /* Copy the received container to UeCb */
9769                      memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9770
9771                      if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9772                      {
9773                         DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9774                         return RFAILED;
9775                      }
9776                      break;
9777                   }
9778                }
9779             }
9780             if(srcDuDb && ueCbInSrcDu)
9781                break;
9782          }
9783       }
9784       else if(ueCb->hoInfo.HOType == Xn_Based_Inter_CU_HO)
9785       {
9786          BuildAndSendHOReqAck(ueCb, duToCuRrcContainer->buf, duToCuRrcContainer->size);
9787       }
9788    }
9789
9790    return ROK;
9791 }
9792
9793 /****************************************************************
9794  * @brief Function to process Ul Rrc Msg received from DU
9795  *
9796  * @details
9797  *
9798  *    Function : procUlRrcMsg
9799  *
9800  *    Functionality:
9801  *         - Function to process Ul Rrc Msg received from DU
9802  *
9803  * @params[in]
9804  * @return ROK     - success
9805  *         RFAILED - failure
9806  *
9807  * ****************************************************************/
9808
9809 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9810 {
9811    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9812    uint8_t  *rrcContainer = NULLP;
9813    uint16_t rrcContLen = 0;
9814    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9815    DuDb     *duDb = NULLP;
9816    CuUeCb   *ueCb = NULLP;
9817    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9818
9819    ret = ROK;
9820    SEARCH_DU_DB(duIdx, duId, duDb);
9821    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9822
9823    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9824    {
9825       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9826       {
9827          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9828             {
9829                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9830                break;
9831             }
9832          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9833             {
9834                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9835                break;
9836             }
9837          case ProtocolIE_ID_id_SRBID:
9838             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9839             break;
9840
9841          case ProtocolIE_ID_id_RRCContainer:
9842             {
9843                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9844                CU_ALLOC(rrcContainer, rrcContLen);
9845                if(!rrcContainer)
9846                {
9847                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9848                   return RFAILED;
9849                }
9850                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9851
9852                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9853                {
9854                   if(duDb->ueCb[duUeF1apId-1].hoInfo.HOType == Inter_DU_HO)
9855                   {
9856                      uint8_t ueIdx = 0;
9857                      uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.srcNodeId;
9858                      DuDb *srcDuDb = NULLP;
9859
9860                      /* Release UE context in source DU because the UE is now
9861                       * attached to target DU */
9862                      SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9863                      for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9864                      {
9865                         if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9866                         {
9867                            ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9868                            if(ret != ROK)
9869                            {
9870                               DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9871                            }
9872                            break;
9873                         }
9874                      }
9875                   }
9876                   else
9877                   {
9878                      BuildAndSendUeContextRelease(&duDb->ueCb[duUeF1apId-1]);
9879                   }
9880
9881                   /* In target DU DB, mark UE as active and delete HO info */
9882                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9883                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9884                   return ret;
9885                }
9886                break;
9887             }
9888
9889          default:
9890             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9891             break;
9892       }
9893    }
9894
9895    if(srbId == 1)
9896    {
9897       ueCb = &duDb->ueCb[duUeF1apId-1];
9898       ueCb->f1apMsgDb.dlRrcMsgCount++;
9899       rrcMsgType = setDlRRCMsgType(ueCb);
9900       if(rrcMsgType == REGISTRATION_COMPLETE)
9901       {
9902          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9903          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9904       }
9905       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9906       {
9907          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9908          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9909       }
9910       else
9911       {
9912          /* In case rrcMsgType is RRC_SETUP_COMPLETE / NAS_AUTHENTICATION_RSP / NAS_SECURITY_MODE_COMPLETE / RRC_SECURITY_MODE_COMPLETE */
9913          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9914       }
9915    }
9916    return ret;
9917 }
9918
9919 /****************************************************************
9920  * @brief Build And Send F1ResetAck
9921  *
9922  * @details
9923  *
9924  *    Function : FreeF1ResetAck
9925  *
9926  *    Functionality:
9927  *         - Build And Send  F1ResetRSP
9928  *
9929  *  @params[in]
9930  * @return ROK     - success
9931  *         RFAILED - failure
9932  *
9933  * ****************************************************************/
9934 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9935 {
9936    uint8_t idx;
9937    ResetAcknowledge_t *f1ResetAck;
9938
9939    if(f1apMsg)
9940    {
9941       if(f1apMsg->choice.successfulOutcome)
9942       {
9943          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9944
9945          if(f1ResetAck->protocolIEs.list.array)
9946          {
9947             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9948             {
9949                if(f1ResetAck->protocolIEs.list.array[idx])
9950                {
9951                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9952                }
9953             }
9954             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9955          }
9956          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9957       }
9958       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9959    }
9960 }
9961
9962 /****************************************************************
9963  * @brief Build And Send F1ResetAck
9964  *
9965  * @details
9966  *
9967  *    Function : BuildAndSendF1ResetAck
9968  *
9969  *    Functionality:
9970  *         - Build And Send  F1ResetRSP
9971  *
9972  *  @params[in]
9973  * @return ROK     - success
9974  *         RFAILED - failure
9975  *
9976  * ****************************************************************/
9977
9978 uint8_t BuildAndSendF1ResetAck()
9979 {
9980    uint8_t                idx = 0;
9981    uint8_t                elementCnt = 0;
9982    uint8_t                ret = RFAILED;
9983    F1AP_PDU_t             *f1apMsg = NULL;
9984    ResetAcknowledge_t     *f1ResetAck = NULLP;
9985    asn_enc_rval_t         encRetVal;
9986    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9987
9988    do{
9989       /* Allocate the memory for F1ResetRequest_t */
9990       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9991       if(f1apMsg == NULLP)
9992       {
9993          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9994          break;
9995       }
9996
9997       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9998
9999       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10000       if(f1apMsg->choice.successfulOutcome == NULLP)
10001       {
10002          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10003          break;
10004       }
10005
10006       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
10007       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10008       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10009       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10010
10011       elementCnt = 1;
10012
10013       f1ResetAck->protocolIEs.list.count = elementCnt;
10014       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10015
10016       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10017       if(f1ResetAck->protocolIEs.list.array == NULLP)
10018       {
10019          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10020          break;
10021       }
10022
10023       for(idx=0; idx<elementCnt; idx++)
10024       {
10025          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10026          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10027          {
10028             break;
10029          }
10030       }
10031       /*TransactionID*/
10032       idx = 0;
10033       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10034       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10035       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10036       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10037
10038       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10039
10040       /* Encode the F1SetupRequest type as UPER */
10041       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10042       encBufSize = 0;
10043       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10044
10045       /* Check encode results */
10046       if(encRetVal.encoded == ENCODE_FAIL)
10047       {
10048          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10049                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10050          break;
10051       }
10052       else
10053       {
10054          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
10055          for(int i=0; i< encBufSize; i++)
10056          {
10057             DU_LOG("%x",encBuf[i]);
10058          }
10059       }
10060
10061       /* Sending msg */
10062       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10063       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
10064       {
10065          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
10066          break;
10067       }
10068
10069       ret = ROK;
10070       break;
10071    }while(true);
10072
10073    FreeF1ResetAck(f1apMsg);
10074    return ret;
10075 }
10076
10077 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10078 {
10079    uint8_t arrIdx =0;
10080
10081    if(ulInfo->list.array)
10082    {
10083       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
10084       {
10085          if(ulInfo->list.array[arrIdx])
10086          {
10087             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
10088             {
10089                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
10090                {
10091                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
10092                   {
10093                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10094                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10095                      gTPTunnel->gTP_TEID.size);
10096                   }
10097                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10098                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10099                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10100                }
10101                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10102                sizeof(GTPTunnel_t));
10103             }
10104             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10105          }
10106       }
10107       CU_FREE(ulInfo->list.array,ulInfo->list.size);
10108    }
10109 }
10110
10111 /*******************************************************************
10112 *
10113 * @brief Deletes the EGTP tunnel
10114 *
10115 * @details
10116 *
10117 *    Function : deleteEgtpTunnel
10118 *
10119 *    Functionality: Deletes the EGTP tunnel
10120 *
10121 * @params[in] uint8_t *buf
10122 *
10123 * @return ROK     - success
10124 *         RFAILED - failure
10125 *
10126 * ****************************************************************/
10127 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
10128 {
10129    uint32_t teId = 0;
10130    EgtpTnlEvt tnlEvt;
10131
10132    teIdStringToInt(buf, &teId);
10133    if(teId > MAX_TEID || teId < MIN_TEID)
10134    {
10135       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
10136       return RFAILED;
10137    }
10138    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
10139    tnlEvt.action = EGTP_TNL_MGMT_DEL;
10140    tnlEvt.lclTeid = teId;
10141    tnlEvt.remTeid = teId;
10142    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
10143    {
10144       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
10145    }
10146    return ROK;
10147 }
10148
10149 /*******************************************************************
10150 *
10151 * @brief Builds the Uplink Tunnel Info
10152 *
10153 * @details
10154 *
10155 *    Function : BuildUlTnlInfoforSetupMod
10156 *
10157 *    Functionality: Constructs the UL TnlInfo For DRB list
10158 *
10159 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10160 *
10161 * @return ROK     - success
10162 *         RFAILED - failure
10163 *
10164 * ****************************************************************/
10165 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
10166 {
10167    uint8_t arrIdx;
10168    uint8_t ulCnt;
10169
10170    ulCnt = 1;
10171    ulInfo->list.count = ulCnt;
10172    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
10173    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
10174    if(ulInfo->list.array == NULLP)
10175    {
10176       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10177       return RFAILED;
10178    }
10179    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
10180    {
10181       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10182       if(ulInfo->list.array[arrIdx] == NULLP)
10183       {
10184          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10185          return RFAILED;
10186       }
10187    }
10188
10189    arrIdx = 0;
10190    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
10191    UPTransportLayerInformation_PR_gTPTunnel;
10192
10193    /*GTP TUNNEL*/
10194    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10195          sizeof(GTPTunnel_t));
10196    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
10197    {
10198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10199       return RFAILED;
10200    }
10201    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10202       transportLayerAddress.size        = 4*sizeof(uint8_t);
10203    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10204          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10205          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10206    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10207          transportLayerAddress.buf == NULLP)
10208    {
10209       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10210       return RFAILED;
10211    }
10212
10213    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10214       transportLayerAddress.buf[0] = 192;
10215    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10216       transportLayerAddress.buf[1] = 168;
10217    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10218       transportLayerAddress.buf[2] = 130;
10219    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10220       transportLayerAddress.buf[3] = 82;
10221    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10222       transportLayerAddress.bits_unused = 0;
10223
10224    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
10225    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
10226    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
10227    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
10228
10229    /*GTP TEID*/
10230    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
10231       = 4 * sizeof(uint8_t);
10232    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10233          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10234          gTPTunnel->gTP_TEID.size);
10235    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10236          == NULLP)
10237    {
10238       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10239       return RFAILED;
10240    }
10241    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10242       gTP_TEID.buf[0] = 0;
10243    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10244       gTP_TEID.buf[1] = 0;
10245    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10246       gTP_TEID.buf[2] = 0;
10247    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
10248    {
10249      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
10250       * fetched based on the Drb Id */
10251
10252      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
10253       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
10254                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
10255    }
10256    else
10257    {
10258       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10259         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
10260    }
10261
10262    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
10263    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
10264    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
10265    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
10266    return ROK;
10267 }/*End of BuildULTnlInfo*/
10268
10269 /*******************************************************************
10270 *
10271 * @brief freeing the DRB item
10272 *
10273 * @details
10274 *
10275 *    Function : FreeDrbItem
10276 *
10277 *    Functionality: freeing the DRB item
10278 *
10279 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10280 *
10281 * @return ROK     - success
10282 *         RFAILED - failure
10283 *
10284 * ****************************************************************/
10285
10286 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
10287 {
10288    uint8_t arrIdx =0;
10289    SNSSAI_t *snssai =NULLP;
10290    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10291
10292    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10293    switch(drbItem->qoSInformation.present)
10294    {
10295       case QoSInformation_PR_NOTHING:
10296          break;
10297       case QoSInformation_PR_eUTRANQoS:
10298          {
10299             if(drbItem->qoSInformation.choice.eUTRANQoS)
10300             {
10301                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10302             }
10303             break;
10304          }
10305       case QoSInformation_PR_choice_extension:
10306          {
10307             if(drbItem->qoSInformation.choice.choice_extension)
10308             {
10309                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10310
10311                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10312                if(snssai->sST.buf)
10313                {
10314                   CU_FREE(snssai->sST.buf,snssai->sST.size);
10315                }
10316                if(snssai->sD)
10317                {
10318                   if(snssai->sD->buf)
10319                   {
10320                      CU_FREE(snssai->sD->buf,snssai->sD->size);
10321                   }
10322                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10323                }
10324
10325                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10326                if(flowMap->list.array)
10327                {
10328                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10329                   {
10330                      if(flowMap->list.array[arrIdx] )
10331                      {
10332                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10333                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10334                      }
10335                   }
10336                   CU_FREE(flowMap->list.array,flowMap->list.size);
10337                }
10338
10339                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10340             }
10341             break;
10342          }
10343
10344    }
10345    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10346    if(drbItem->uLConfiguration)
10347    {
10348       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10349    }
10350 }
10351
10352 /*******************************************************************
10353 *
10354 * @brief filling the DRB setup Mod item
10355 *
10356 * @details
10357 *
10358 *    Function : FillDrbItemToSetupMod
10359 *
10360 *    Functionality: filling the DRB setup Mod item
10361 *
10362 *
10363 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10364 *
10365 * @return ROK     - success
10366 *         RFAILED - failure
10367 *
10368 * ****************************************************************/
10369
10370 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
10371 {
10372    uint8_t ret = ROK;
10373
10374    /*Drb Id */
10375    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
10376    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
10377
10378    /*qoSInformation*/
10379    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10380
10381    switch(drbItem->qoSInformation.present)
10382    {
10383       case QoSInformation_PR_NOTHING:
10384       {
10385          break;
10386       }
10387       case QoSInformation_PR_eUTRANQoS:
10388       {
10389
10390          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10391          if(drbItem->qoSInformation.choice.eUTRANQoS)
10392          {
10393             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10394             return RFAILED;
10395          }
10396          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10397          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10398             PriorityLevel_no_priority;
10399
10400          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10401             Pre_emptionCapability_may_trigger_pre_emption;
10402
10403          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10404             Pre_emptionVulnerability_pre_emptable;
10405
10406          break;
10407       }
10408       case QoSInformation_PR_choice_extension:
10409       {
10410          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10411          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10412          {
10413             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10414             return RFAILED;
10415          }
10416
10417          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10418          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10419          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10420          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10421            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10422          if(ret != ROK)
10423          {
10424             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10425             return RFAILED;
10426          }
10427
10428          /*SNSSAI*/
10429          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10430                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10431          if(ret != ROK)
10432          {
10433             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10434             return RFAILED;
10435          }
10436
10437          /*Flows mapped to DRB List*/
10438          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10439                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10440           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10441          if(ret != ROK)
10442          {
10443             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10444             return RFAILED;
10445          }
10446       }
10447    }
10448
10449    /*ULUPTNLInformation To Be Setup List*/
10450    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10451       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10452    if(ret != ROK)
10453    {
10454       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10455       return RFAILED;
10456    }
10457
10458    /*RLCMode*/
10459    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10460    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10461
10462    ueCb->numDrb++;
10463    return ROK;
10464 }
10465
10466 /*******************************************************************
10467 *
10468 * @brief Builds the DRB to be Setup Mod ItemIes
10469 *
10470 * @details
10471 *
10472 *    Function : FillDrbItemList
10473 *
10474 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10475 *
10476 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10477 *
10478 * @return ROK     - success
10479 *         RFAILED - failure
10480 *
10481 * ****************************************************************/
10482
10483 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10484 {
10485    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10486    drbItemIe->criticality = Criticality_reject;
10487    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10488
10489    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10490    {
10491       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10492       return RFAILED;
10493    }
10494    return ROK;
10495 }
10496 /*******************************************************************
10497 *
10498 * @brief free the DRB to be Setup Mod list
10499 *
10500 * @details
10501 *
10502 *    Function : FreeDrbToBeSetupModList
10503 *
10504 *    Functionality: free the DRB to be Setup Mod list
10505 *
10506 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10507 *
10508 * @return ROK     - success
10509 *         RFAILED - failure
10510 *
10511 * ****************************************************************/
10512 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10513 {
10514    uint8_t arrIdx =0;
10515    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10516
10517    if(drbSet->list.array)
10518    {
10519       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10520       {
10521          if(drbSet->list.array[arrIdx] != NULLP)
10522          {
10523             if(arrIdx == 0)
10524             {
10525                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10526                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10527             }
10528             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10529          }
10530       }
10531       CU_FREE(drbSet->list.array, drbSet->list.size);
10532    }
10533
10534 }
10535
10536 /*******************************************************************
10537 *
10538 * @brief Builds the DRB to be Setup Mod list
10539 *
10540 * @details
10541 *
10542 *    Function : BuildDrbToBeSetupList
10543 *
10544 *    Functionality: Constructs the DRB to be Setup Mod list
10545 *
10546 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10547 *
10548 * @return ROK     - success
10549 *         RFAILED - failure
10550 *
10551 * ****************************************************************/
10552
10553 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10554 {
10555    uint8_t ret = ROK;
10556    uint8_t arrIdx =0;
10557    uint8_t drbCnt =0;
10558
10559    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10560    drbSet->list.count = drbCnt;
10561    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10562    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10563    if(drbSet->list.array == NULLP)
10564    {
10565       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10566       return  RFAILED;
10567    }
10568
10569    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10570    {
10571       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10572       if(drbSet->list.array[arrIdx] == NULLP)
10573       {
10574          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10575          return  RFAILED;
10576       }
10577
10578       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10579       if(ret != ROK)
10580       {
10581          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10582       }
10583    }
10584
10585    return ret;
10586 }
10587
10588 /*******************************************************************
10589 *
10590 * @brief Filling the DRB to be modified item
10591 *
10592 * @details
10593 *
10594 *    Function : FillDrbToBeModItem
10595 *
10596 *    Functionality: filling the DRB to be modified item
10597 *
10598 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10599 *
10600 * @return ROK     - success
10601 *         RFAILED - failure
10602 *
10603 * ****************************************************************/
10604
10605 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10606 {
10607    uint8_t ret = ROK;
10608    uint drbIdx=0;
10609    DrbInfo *drbToBeMod;
10610
10611    /*Drb Id */
10612    drbItem->dRBID = DRB2 + arrIdx;
10613
10614    /* Search for DRB ID in CU databse */
10615    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10616    {
10617       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10618       {
10619          drbToBeMod = &ueCb->drbList[drbIdx];
10620          break;
10621       }
10622    }
10623
10624    /*qoSInformation*/
10625    drbItem->qoSInformation = NULLP;
10626    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10627    if(drbItem->qoSInformation != NULLP)
10628    {
10629       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10630
10631       switch(drbItem->qoSInformation->present)
10632       {
10633          case QoSInformation_PR_NOTHING:
10634             {
10635                break;
10636             }
10637          case QoSInformation_PR_eUTRANQoS:
10638             {
10639
10640                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10641                if(drbItem->qoSInformation->choice.eUTRANQoS)
10642                {
10643                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10644                   return RFAILED;
10645                }
10646                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10647                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10648                   PriorityLevel_no_priority;
10649
10650                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10651                   Pre_emptionCapability_may_trigger_pre_emption;
10652
10653                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10654                   Pre_emptionVulnerability_pre_emptable;
10655
10656                break;
10657             }
10658          case QoSInformation_PR_choice_extension:
10659             {
10660                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10661                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10662                {
10663                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10664                   return RFAILED;
10665                }
10666
10667                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10668                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10669                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10670                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10671                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10672                if(ret != ROK)
10673                {
10674                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10675                   return RFAILED;
10676                }
10677
10678                /*SNSSAI*/
10679                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10680                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10681                if(ret != ROK)
10682                {
10683                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10684                   return RFAILED;
10685                }
10686
10687                /*Flows mapped to DRB List*/
10688                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10689                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10690                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10691                if(ret != ROK)
10692                {
10693                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10694                   return RFAILED;
10695                }
10696             }
10697       }
10698    }/* End of QoS */
10699
10700    /*ULUPTNLInformation To Be Setup List*/
10701    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10702             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10703    if(ret != ROK)
10704    {
10705       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10706       return RFAILED;
10707    }
10708    return ROK;
10709 }
10710
10711 /*******************************************************************
10712 *
10713 * @brief Builds the DRB to be modified Item IE
10714 *
10715 * @details
10716 *
10717 *    Function : FillDrbToBeModItemList
10718 *
10719 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10720 *
10721 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10722 *
10723 * @return ROK     - success
10724 *         RFAILED - failure
10725 *
10726 * ****************************************************************/
10727
10728 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10729 {
10730    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10731    drbItemIe->criticality = Criticality_reject;
10732    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10733    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10734    {
10735       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10736       return RFAILED;
10737    }
10738
10739    return ROK;
10740 }
10741
10742 /*******************************************************************
10743 *
10744 * @brief Builds the DRB to be modified list
10745 *
10746 * @details
10747 *
10748 *    Function : BuildDrbToBeModList
10749 *
10750 *    Functionality: Constructs the DRB to be modified list
10751 *
10752 * @params[in] DRBs_ToBeModified_List_t *drbSet
10753 *
10754 * @return ROK     - success
10755 *         RFAILED - failure
10756 *
10757 * ****************************************************************/
10758
10759 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10760 {
10761    uint8_t ret = ROK;
10762    uint8_t arrIdx =0;
10763    uint8_t drbCnt =0;
10764
10765    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10766    drbSet->list.count = drbCnt;
10767    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10768    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10769    if(drbSet->list.array == NULLP)
10770    {
10771       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10772       return  RFAILED;
10773    }
10774    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10775    {
10776       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10777       if(drbSet->list.array[arrIdx] == NULLP)
10778       {
10779          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10780          return  RFAILED;
10781       }
10782
10783       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10784       if(ret != ROK)
10785       {
10786          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10787       }
10788    }
10789
10790    return ret;
10791 }
10792
10793 /*******************************************************************
10794 *
10795 * @brief Builds the DRB to be released Item IE
10796 *
10797 * @details
10798 *
10799 *    Function : FillDrbToBeRelItemList
10800 *
10801 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10802 *
10803 * @params[in] struct DRBs_ToBeReleased_ItemIEs *drbItemIe
10804 *
10805 * @return ROK     - success
10806 *         RFAILED - failure
10807 *
10808 * ****************************************************************/
10809
10810 uint8_t FillDrbToBeRelItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeReleased_ItemIEs *drbItemIe)
10811 {
10812    uint8_t drbIdx;
10813
10814    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeReleased_Item;
10815    drbItemIe->criticality = Criticality_reject;
10816    drbItemIe->value.present = DRBs_ToBeReleased_ItemIEs__value_PR_DRBs_ToBeReleased_Item;
10817    drbItemIe->value.choice.DRBs_ToBeReleased_Item.dRBID = DRB1 + arrIdx;
10818
10819    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10820    {
10821       if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_ToBeReleased_Item.dRBID)
10822       {
10823          deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
10824          CU_FREE(ueCb->drbList[drbIdx].snssai, sizeof(Snssai));
10825          break;
10826       }
10827    }
10828    return ROK;
10829 }
10830
10831 /*******************************************************************
10832 *
10833 * @brief Builds the DRB to be released list
10834 *
10835 * @details
10836 *
10837 *    Function : BuildDrbToBeReleasedList
10838 *
10839 *    Functionality: Constructs the DRB to be released list
10840 *
10841 * @params[in] DRBs_ToBeReleased_List_t *drbSet
10842 *
10843 * @return ROK     - success
10844 *         RFAILED - failure
10845 *
10846 * ****************************************************************/
10847
10848 uint8_t BuildDrbToBeReleasedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeReleased_List_t *drbSet)
10849 {
10850    uint8_t ret = ROK;
10851    uint8_t arrIdx =0;
10852    uint8_t drbCnt =0;
10853
10854    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10855    drbSet->list.count = drbCnt;
10856    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeReleased_ItemIEs_t *);
10857    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10858    if(drbSet->list.array == NULLP)
10859    {
10860       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
10861       return  RFAILED;
10862    }
10863    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10864    {
10865       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeReleased_ItemIEs_t));
10866       if(drbSet->list.array[arrIdx] == NULLP)
10867       {
10868          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
10869          return  RFAILED;
10870       }
10871
10872       ret = FillDrbToBeRelItemList(duId, ueCb, arrIdx, (DRBs_ToBeReleased_ItemIEs_t *)drbSet->list.array[arrIdx]);
10873       if(ret != ROK)
10874       {
10875          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeRelItemList failed");
10876       }
10877    }
10878
10879    return ret;
10880 }
10881
10882 /*******************************************************************
10883 *
10884 * @brief freeing the DRB  item
10885 *
10886 * @details
10887 *
10888 *    Function : FreeModifiedDrbItem
10889 *
10890 *    Functionality: freeing the DRB 2 item
10891 *
10892 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10893 *
10894 * @return ROK     - success
10895 *         RFAILED - failure
10896 *
10897 * ****************************************************************/
10898
10899 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10900 {
10901    uint8_t arrIdx =0;
10902    SNSSAI_t *snssai =NULLP;
10903    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10904
10905    if(drbItem->qoSInformation != NULLP)
10906    {
10907       switch(drbItem->qoSInformation->present)
10908       {
10909          case QoSInformation_PR_NOTHING:
10910             break;
10911          case QoSInformation_PR_eUTRANQoS:
10912             {
10913                if(drbItem->qoSInformation->choice.eUTRANQoS)
10914                {
10915                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10916                }
10917                break;
10918             }
10919          case QoSInformation_PR_choice_extension:
10920             {
10921                if(drbItem->qoSInformation->choice.choice_extension)
10922                {
10923                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10924
10925                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10926                   if(snssai->sST.buf)
10927                   {
10928                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10929                   }
10930                   if(snssai->sD)
10931                   {
10932                      if(snssai->sD->buf)
10933                      {
10934                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10935                      }
10936                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10937                   }
10938
10939                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10940                   if(flowMap->list.array)
10941                   {
10942                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10943                      {
10944                         if(flowMap->list.array[arrIdx] )
10945                         {
10946                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10947                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10948                         }
10949                      }
10950                      CU_FREE(flowMap->list.array,flowMap->list.size);
10951                   }
10952
10953                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10954                }
10955                break;
10956             }
10957       }
10958    }
10959    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10960    if(drbItem->uLConfiguration)
10961    {
10962       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10963    }
10964 }
10965
10966 /*******************************************************************
10967 *
10968 * @brief free the DRB to be modfified list
10969 *
10970 * @details
10971 *
10972 *    Function : FreeDrbToBeModifiedList
10973 *
10974 *    Functionality: free the DRB to be Setup Mod list
10975 *
10976 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10977 *
10978 * @return ROK     - success
10979 *         RFAILED - failure
10980 *
10981 * ****************************************************************/
10982 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10983 {
10984    uint8_t arrIdx =0;
10985    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10986
10987    if(drbSet->list.array)
10988    {
10989       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10990       {
10991          if(drbSet->list.array[arrIdx] != NULLP)
10992          {
10993             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10994             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10995             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10996          }
10997       }
10998       CU_FREE(drbSet->list.array, drbSet->list.size);
10999    }
11000
11001 }
11002
11003 /*******************************************************************
11004 *
11005 * @brief free the DRB to be modfified list
11006 *
11007 * @details
11008 *
11009 *    Function : FreeDrbToBeReleasedList
11010 *
11011 *    Functionality: free the DRB to be Release list
11012 *
11013 * @params[in] FreeDrbToBeReleasedList_t *drbSet
11014 *
11015 * @return ROK     - success
11016 *         RFAILED - failure
11017 *
11018 * ****************************************************************/
11019 void FreeDrbToBeReleasedList(DRBs_ToBeReleased_List_t *drbSet)
11020 {
11021    uint8_t arrIdx =0;
11022    struct DRBs_ToBeReleased_ItemIEs *drbItemIe;
11023
11024    if(drbSet->list.array)
11025    {
11026       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
11027       {
11028          if(drbSet->list.array[arrIdx] != NULLP)
11029          {
11030             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeReleased_ItemIEs_t));
11031          }
11032       }
11033       CU_FREE(drbSet->list.array, drbSet->list.size);
11034    }
11035 }
11036
11037 /*******************************************************************
11038  *
11039  * @brief  free the UeContextModification Request
11040  *
11041  * @details
11042  *
11043  *    Function : FreeUeContextModicationRequest
11044  *
11045  *    Functionality : deallocation of memory allocated in UeContextModiification
11046  request
11047  *
11048  * @params[in] F1AP_PDU_t *f1apMsg
11049  *
11050  * @return void
11051 *
11052 * ****************************************************************/
11053 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
11054 {
11055    uint8_t arrIdx =0 , ieId=0;
11056    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
11057
11058    if(f1apMsg)
11059    {
11060       if(f1apMsg->choice.initiatingMessage)
11061       {
11062          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
11063          if(ueContextModifyReq->protocolIEs.list.array)
11064          {
11065             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
11066             {
11067                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
11068                {
11069                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
11070                   switch(ieId)
11071                   {
11072                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11073                         break;
11074                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11075                         break;
11076                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
11077                         {
11078                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11079                                  choice.DRBs_ToBeSetupMod_List);
11080                            break;
11081                         }
11082                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
11083                         {
11084                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11085                                  choice.DRBs_ToBeModified_List);
11086                            break;
11087                         }
11088                      case ProtocolIE_ID_id_DRBs_ToBeReleased_List:
11089                         {
11090                            FreeDrbToBeReleasedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11091                                  choice.DRBs_ToBeReleased_List);
11092                            break;
11093                         }
11094                     case ProtocolIE_ID_id_TransmissionActionIndicator:
11095                         break;
11096                     case ProtocolIE_ID_id_RRCContainer:
11097                     {
11098                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
11099                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
11100                     }
11101
11102                   }
11103                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
11104                }
11105             }
11106             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
11107          }
11108          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11109       }
11110       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11111    }
11112 }
11113
11114 /*******************************************************************
11115  *
11116  * @brief Builds the Ue Context Modification Req
11117  *
11118  * @details
11119  *
11120  *    Function : BuildAndSendUeContextModificationReq
11121  *
11122  *    Functionality: Constructs the Ue Context Modification Req
11123  *
11124  * @params[in]
11125  *
11126  * @return ROK     - success
11127  *         RFAILED - failure
11128  *
11129  * ****************************************************************/
11130 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
11131 {
11132    uint8_t    ieIdx = 0;
11133    uint8_t    elementCnt = 0;
11134    uint8_t    ret = RFAILED;
11135    uint16_t   tmpBufIdx = 0, bufIdx = 0;
11136    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
11137    F1AP_PDU_t *f1apMsg = NULLP;
11138    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
11139    RRCContainer_t rrcContainerTmp, *rrcContainer = NULLP;
11140    asn_enc_rval_t         encRetVal;
11141    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
11142    while(1)
11143    {
11144       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11145       if(f1apMsg == NULLP)
11146       {
11147          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11148          break;
11149       }
11150
11151       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11152
11153       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11154       if(f1apMsg->choice.initiatingMessage == NULLP)
11155       {
11156          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11157          break;
11158       }
11159       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
11160       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11161       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
11162
11163       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
11164
11165       if(action == MODIFY_UE)
11166          elementCnt = 5;
11167       else if(action == QUERY_CONFIG)
11168          elementCnt = 3;
11169       else if(action == RRC_RECONFIG_COMPLETE_IND)
11170          elementCnt = 3;
11171       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11172       {
11173          if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11174             elementCnt = 5;
11175          else
11176             elementCnt = 4;
11177       }
11178
11179 #ifdef NR_DRX
11180       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
11181          elementCnt++;
11182 #endif
11183       ueContextModifyReq->protocolIEs.list.count = elementCnt;
11184       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
11185
11186       /* Initialize the UE context modification members */
11187       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
11188       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
11189       {
11190          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11191          break;
11192       }
11193
11194       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11195       {
11196          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
11197          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
11198          {
11199             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11200             break;
11201          }
11202       }
11203
11204       ieIdx=0;
11205       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11206       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11207       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11208                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
11209       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
11210
11211       ieIdx++;
11212       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11213       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11214       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
11215                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
11216       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
11217
11218       if(action == MODIFY_UE)
11219       {
11220          /* DRB to be setup list */
11221          ieIdx++;
11222          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
11223          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11224          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11225                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
11226          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11227                   value.choice.DRBs_ToBeSetupMod_List));
11228
11229          /* DRB to be modified list */
11230          ieIdx++;
11231          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
11232          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11233          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11234                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
11235          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11236                   value.choice.DRBs_ToBeModified_List));
11237
11238          if(ret != ROK)
11239          {
11240             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
11241             break;
11242          }
11243
11244          /* DRB to be released list */
11245          ieIdx++;
11246          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeReleased_List;
11247          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11248          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11249                                                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeReleased_List;
11250          ret = BuildDrbToBeReleasedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11251                   value.choice.DRBs_ToBeReleased_List));
11252
11253          if(ret != ROK)
11254          {
11255             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be deleted list");
11256             break;
11257          }
11258       }
11259       else if(action == QUERY_CONFIG)
11260       {
11261          ieIdx++;
11262          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
11263          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11264          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11265             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
11266          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
11267       }
11268       else if(action == RRC_RECONFIG_COMPLETE_IND)
11269       {
11270          ieIdx++;
11271          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
11272          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11273          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11274             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
11275          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
11276             RRCReconfigurationCompleteIndicator_true;
11277       }
11278       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11279       {
11280          ieIdx++;
11281          if(action == STOP_DATA_TX)
11282          {
11283             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11284             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11285             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11286             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11287             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11288             TransmissionActionIndicator_stop;
11289          }
11290          else if (action == RESTART_DATA_TX)
11291          {
11292             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11293             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11294             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11295             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11296             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11297             TransmissionActionIndicator_restart;
11298          }
11299
11300          ieIdx++;
11301          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11302          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11303          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCContainer;
11304          if(fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, true) != ROK)
11305          {
11306             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
11307             return RFAILED;
11308          }
11309
11310          rrcContainer = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11311          rrcContainer->size = rrcContainerTmp.size + 2; /* 2 bytes of PDCP SN */
11312          CU_ALLOC(rrcContainer->buf, rrcContainer->size);
11313          memset(rrcContainer->buf, 0, rrcContainer->size);
11314          rrcContainer->buf[0] = 0x00;
11315          rrcContainer->buf[1] = ueCb->pdcpSn; //PDCP SN
11316          for(bufIdx = 2, tmpBufIdx = 0; bufIdx < rrcContainer->size; bufIdx++, tmpBufIdx++)
11317          {
11318             rrcContainer->buf[bufIdx] = rrcContainerTmp.buf[tmpBufIdx];
11319          }
11320
11321          /* RRC delivery status request */
11322          if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11323          {
11324             ieIdx++;
11325             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
11326             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11327             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
11328             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
11329          }
11330       }
11331
11332 #ifdef NR_DRX
11333       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
11334       {
11335          /* DRX Configuration Indicator */
11336          ieIdx++;
11337          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRXConfigurationIndicator;
11338          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11339          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_DRXConfigurationIndicator;
11340          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.DRXConfigurationIndicator = DRXConfigurationIndicator_release;
11341          ueCb->drxCfgPresent = false;
11342          memset(&ueCb->drxCfg, 0, sizeof(DrxCfg));
11343       }
11344 #endif
11345
11346       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11347
11348       /* Encode the F1SetupRequest type as APER */
11349       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11350       encBufSize = 0;
11351       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11352
11353       /* Encode results */
11354       if(encRetVal.encoded == ENCODE_FAIL)
11355       {
11356          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
11357                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11358          break;
11359       }
11360       else
11361       {
11362          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
11363 #if 0
11364          /* This for loop was going into an infinite loop even though encBufSize
11365           * has a small value. Hence commented this
11366           */
11367          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11368          {
11369             DU_LOG("%x",encBuf[ieIdx]);
11370          }
11371 #endif
11372       }
11373
11374       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11375       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11376       {
11377          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
11378          break;
11379       }
11380
11381       ret = ROK;
11382       break;
11383
11384    }
11385    FreeUeContextModicationRequest(f1apMsg);
11386    return ret;
11387 }
11388
11389 /*****************************************************************i
11390  *
11391 * @brief Free memory allocated for UE Context Release Command
11392 *
11393 * @details
11394 *
11395 *    Function : FreeUeContextReleaseCommand
11396 *
11397 *    Functionality:
11398 *         - Free memory allocated for UE Context Release Command
11399 *
11400 * @params[in] F1AP_PDU_t *f1apMsg
11401 * @return void
11402 *
11403 * *************************************************************/
11404 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
11405 {
11406    uint8_t ieIdx;
11407    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
11408
11409    if(f1apMsg)
11410    {
11411       if(f1apMsg->choice.initiatingMessage)
11412       {
11413          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11414          if(ueReleaseCommand->protocolIEs.list.array)
11415          {
11416             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
11417             {
11418                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11419             }
11420             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
11421          }
11422          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11423       }
11424       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11425    }
11426 }
11427 /*******************************************************************
11428  *
11429  * @brief Builds the Ue Context Release Command
11430  *
11431  * @details
11432 *
11433 *    Function : BuildAndSendUeContextReleaseCommand
11434 *
11435 *    Functionality: Constructs the Ue Context Release Command
11436 *
11437 * @params[in]
11438 *
11439 * @return ROK     - success
11440 *         RFAILED - failure
11441 *
11442 * ****************************************************************/
11443 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
11444 {
11445    bool       memAllocFailed = false;
11446    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
11447    DuDb *duDb;
11448    CuUeCb *ueCb;
11449    F1AP_PDU_t *f1apMsg = NULLP;
11450    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
11451
11452    asn_enc_rval_t         encRetVal;
11453    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
11454
11455    while(true)
11456    {
11457       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11458       if(f1apMsg == NULLP)
11459       {
11460          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
11461          break;
11462       }
11463
11464       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11465
11466       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11467       if(f1apMsg->choice.initiatingMessage == NULLP)
11468       {
11469          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
11470          break;
11471       }
11472       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
11473       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11474       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
11475
11476       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11477
11478       SEARCH_DU_DB(duIdx, duId, duDb);
11479       ueCb = &duDb->ueCb[duUeF1apId-1];
11480       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11481          elementCnt = 3;
11482       else
11483          elementCnt = 4;
11484
11485       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
11486       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
11487
11488       /* Initialize the UE context modification members */
11489       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
11490       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
11491       {
11492          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
11493          break;
11494       }
11495
11496       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11497       {
11498          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11499          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
11500          {
11501             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
11502             memAllocFailed = true;
11503             break;
11504          }
11505       }
11506
11507       if(memAllocFailed == true)
11508       {
11509          break;
11510       }
11511
11512       ieIdx=0;
11513       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11514       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11515       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11516       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
11517       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
11518
11519       ieIdx++;
11520       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11521       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11522       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11523       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
11524       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
11525
11526       /* Cause of UE context release */
11527       ieIdx++;
11528       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
11529       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11530       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11531                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
11532       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11533       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
11534                                                                                                      CauseRadioNetwork_normal_release;
11535       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11536       {
11537          /* RRC Container for RRC release */
11538          ieIdx++;
11539          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11540          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11541          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11542                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
11543          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
11544          bufLen =7;
11545          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
11546          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
11547                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
11548          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
11549          {
11550             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
11551             break;
11552          }
11553          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
11554          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
11555       }
11556       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11557
11558       /* Encode the UE Context Release Command type as APER */
11559       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11560       encBufSize = 0;
11561       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11562             encBuf);
11563
11564       /* Encode results */
11565       if(encRetVal.encoded == ENCODE_FAIL)
11566       {
11567          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11568                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11569          break;
11570       }
11571       else
11572       {
11573          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
11574          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11575          {
11576             DU_LOG("%x",encBuf[ieIdx]);
11577          }
11578       }
11579
11580       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11581       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11582       {
11583          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11584          break;
11585       }
11586
11587       ret = ROK;
11588       break;
11589
11590    }
11591    FreeUeContextReleaseCommand(f1apMsg);
11592    return ret;
11593 }
11594 /*******************************************************************
11595 *
11596 * @brief process Ue context release request
11597 *
11598 * @details
11599 *
11600 *    Function : procUeContextReleaseReq
11601 *
11602 *    Functionality:
11603 *         - process Ue context release request
11604 *
11605 * @params[in] F1AP_PDU_t *f1apMsg
11606 * @return ROK     - success
11607 *         RFAILED - failure
11608 *
11609 * ****************************************************************/
11610 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11611 {
11612    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11613
11614    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11615    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11616
11617    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11618    {
11619       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11620       {
11621          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11622             {
11623                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11624                break;
11625             }
11626          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11627             {
11628                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11629                break;
11630             }
11631          default:
11632               break;
11633       }
11634    }
11635
11636    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11637    {
11638       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11639       return RFAILED;
11640    }
11641    return ROK;
11642 }
11643 /*******************************************************************
11644 *
11645 * @brief processing of Gnb-DU config update
11646 *
11647 * @details
11648 *
11649 *    Function : procGnbDuUpdate
11650 *
11651 *    Functionality:
11652 *         - processing of Gnb-DU config update
11653 *
11654 * @params[in] F1AP_PDU_t *f1apMsg
11655 * @return ROK     - success
11656 *         RFAILED - failure
11657 *
11658 * ****************************************************************/
11659 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11660 {
11661    bool cellToBeDelete = false;
11662    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11663    uint16_t nrCellId;
11664    DuDb *duDb;
11665    CuCellCb *cellCb;
11666    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11667
11668    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11669    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11670    {
11671       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11672       {
11673          case ProtocolIE_ID_id_TransactionID:
11674             break;
11675          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11676             break;
11677          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11678             {
11679                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11680                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11681                   Served_Cells_To_Delete_List.list.array[0];
11682                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11683                cellToBeDelete = true;
11684                break;
11685             }
11686          case ProtocolIE_ID_id_gNB_DU_ID:
11687             break;
11688       }
11689    }
11690    if(BuildAndSendDUUpdateAck(duId) != ROK)
11691    {
11692       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11693       return RFAILED;
11694    }
11695 #if 0
11696    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11697     * commented this trigger for now */
11698
11699    if(cellToBeDelete == false)
11700    {
11701       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11702       if(BuildAndSendF1ResetReq() != ROK)
11703       {
11704          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11705          return RFAILED;
11706       }
11707    }
11708 #endif
11709    if(cellToBeDelete == true)
11710    {
11711       SEARCH_DU_DB(duIdx, duId, duDb);
11712       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11713       if(cellCb->numUe == 0)
11714       {
11715          memset(cellCb, 0, sizeof(CuCellCb));
11716          duDb->numCells--;
11717       }
11718       else
11719          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11720    }
11721    return ROK;
11722 }
11723
11724 /*******************************************************************
11725 *
11726 * @brief storing slice list in CU database
11727 *
11728 * @details
11729 *
11730 *    Function : buildSliceList
11731 *
11732 *    Functionality:
11733 *         - storing slice list in CU database
11734 *
11735 * @params[in] SliceSupportList_t *sliceSupportList
11736 * @return ROK     - success
11737 *         RFAILED - failure
11738 *
11739 * ****************************************************************/
11740 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11741 {
11742    uint8_t sliceListIdx = 0;
11743
11744    if(sliceSupportList)
11745    {
11746       if(sliceSupportList->list.array)
11747       {
11748          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11749          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11750          {
11751             if(sliceSupportList->list.array[sliceListIdx])
11752             {
11753                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11754                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11755                {
11756                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11757                    return RFAILED;
11758                }
11759                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11760                {
11761                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11762                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11763                }
11764                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11765                {
11766                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11767                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11768                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11769                }
11770             }
11771          }
11772       }
11773    }
11774    return ROK;
11775 }
11776
11777 /****************************************************************
11778  * @brief Function to process Srb Setup Mod List
11779  *
11780  * @details
11781  *
11782  *    Function : procSrbSetupModList
11783  *
11784  *    Functionality:
11785  *         - Function to process SRB Setup Mod List
11786  *
11787  * @params[in]
11788  * @return ROK     - success
11789  *         RFAILED - failure
11790  *
11791  * ****************************************************************/
11792 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11793 {
11794    uint8_t arrIdx = 0, srbIdx;
11795    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11796
11797    if(srbSetupList != NULLP)
11798    {
11799       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11800       {
11801          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11802          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11803          {
11804             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11805             {
11806                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11807                {
11808                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11809                   break;
11810                }
11811             }
11812          }
11813
11814       }
11815    }
11816    return ROK;
11817 }
11818
11819
11820 /****************************************************************
11821  * @brief Function to process Drb Setup Mod List
11822  *
11823  * @details
11824  *
11825  *    Function : procDrbSetupModList
11826  *
11827  *    Functionality:
11828  *         - Function to process DRB Setup Mod List
11829  *
11830  * @params[in]
11831  * @return ROK     - success
11832  *         RFAILED - failure
11833  *
11834  * ****************************************************************/
11835 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11836 {
11837    uint8_t arrIdx = 0, drbIdx;
11838    uint32_t teId = 0;
11839    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11840
11841    if(drbSetupList != NULLP)
11842    {
11843       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11844       {
11845          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11846          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11847          {
11848             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11849             {
11850                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11851                {
11852                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11853                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11854                   break;
11855                }
11856             }
11857
11858             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11859             {
11860                /* extracting teId */
11861                teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11862                if(teId > 0)
11863                {
11864                   if(addDrbTunnels(duId, teId)== ROK)
11865                   {
11866                      DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11867                   }
11868                }
11869                else
11870                   return RFAILED;
11871             }
11872          }
11873       }
11874    }
11875    return ROK;
11876 }
11877
11878 /*******************************************************************
11879 *
11880 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11881 *
11882 * @details
11883 *
11884 *    Function : procServedCellPlmnList
11885 *
11886 *    Functionality:
11887 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11888 *         SNSSAI list
11889 *
11890 * @params[in] F1AP_PDU_t *f1apMsg
11891 * @return ROK     - success
11892 *         RFAILED - failure
11893 *
11894 * ****************************************************************/
11895 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11896 {
11897    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11898    ProtocolExtensionContainer_4624P3_t **ieExtend;
11899
11900    if(srvPlmn->list.array)
11901    {
11902       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11903       {
11904          if(srvPlmn->list.array[srvPlmnIdx])
11905          {
11906             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11907             if(*ieExtend)
11908             {
11909                if((*ieExtend)->list.array)
11910                {
11911                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11912                   {
11913                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11914                      {
11915                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11916                         {
11917                            case ProtocolIE_ID_id_TAISliceSupportList:
11918                               {
11919                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11920                                           extensionValue.choice.SliceSupportList) != ROK)
11921                                  {
11922                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11923                                     return RFAILED;
11924                                  }
11925                               }
11926                         }
11927                      }
11928                   }
11929                }
11930             }
11931          }
11932       }
11933    }
11934    return ROK;
11935 }
11936
11937 /****************************************************************
11938  * @brief Function to process Ue Context Modification Response
11939  *
11940  * @details
11941  *
11942  *    Function : procUeContextModificationResponse
11943  *
11944  *    Functionality:
11945  *         - Function to process Ue Context Modification Response
11946  *
11947  * @params[in]
11948  * @return ROK     - success
11949  *         RFAILED - failure
11950  *
11951  * ****************************************************************/
11952 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg, char *recvBuf, MsgLen recvBufLen)
11953 {
11954    uint8_t idx=0, duIdx=0;
11955    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11956    DuDb *duDb = NULLP;
11957    CuUeCb *ueCb = NULLP;
11958    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11959
11960    SEARCH_DU_DB(duIdx, duId, duDb);
11961    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11962
11963    /* In case of Inter-CU Handover request received from peer CU */
11964    if(duDb->tempUeCtxtInHo)
11965       ueCb = duDb->tempUeCtxtInHo;
11966
11967    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11968    {
11969       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11970       {
11971           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11972              {
11973                 if(ueCb == NULLP)
11974                 {
11975                    cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11976                 }
11977                 else
11978                 {
11979                    /* In case of Inter-CU Handover request received from peer CU */
11980                    cuUeF1apId = ueCb->gnbCuUeF1apId;
11981                 }
11982                 break;
11983              }
11984           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11985              {
11986                 if(!ueCb)
11987                 {
11988                    duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11989                    ueCb = &duDb->ueCb[duUeF1apId-1];
11990
11991                    /* In case UE context modification response is received at source GNB CU from source GNB DU
11992                     * for a UE in handover, send HO request to target GNB only if not sent already.
11993                     * If HO Req is already sent to target GNB, and an HO Req Ack is received, then
11994                     * ueCb->hoInfo.cuUeF1apIdTgt will be non-zero
11995                     */
11996                    if((ueCb->state == UE_HANDOVER_IN_PROGRESS) && (ueCb->hoInfo.HOType == Xn_Based_Inter_CU_HO) && \
11997                       (ueCb->hoInfo.cuUeF1apIdTgt == 0))
11998                    {
11999                       BuildAndSendHOReq(ueCb, recvBuf, recvBufLen);
12000                    }
12001                 }
12002                 break;
12003              }
12004           case ProtocolIE_ID_id_DRBs_SetupMod_List:
12005              {
12006                 /* Adding Tunnels for successful DRB */
12007                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
12008                 break;
12009
12010              }
12011              case ProtocolIE_ID_id_DRBs_Modified_List:
12012              {
12013                 DU_LOG("\nINFO  -->  Received DRBs Modified List");
12014                 break;
12015              }
12016           case ProtocolIE_ID_id_SRBs_SetupMod_List:
12017              {
12018                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
12019                 break;
12020              }
12021          case ProtocolIE_ID_id_DUtoCURRCInformation:
12022              {
12023                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
12024                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
12025                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
12026                 {
12027                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
12028                    return RFAILED;
12029                 }
12030                 break;
12031              }
12032
12033       }
12034    }
12035
12036    /* If UE is in handover and UE context is not yet created at target DU, then send
12037     * UE context setup request to target DU */
12038    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
12039    {
12040       uint8_t ueIdx = 0;
12041       uint8_t tgtDuId = 0;
12042       DuDb *tgtDuDb = NULLP;
12043       CuUeCb *ueCbInTgtDu = NULLP;
12044
12045       if(ueCb->hoInfo.HOType == Inter_DU_HO)
12046       {
12047          tgtDuId = ueCb->hoInfo.tgtNodeId;
12048       }
12049       else if (ueCb->hoInfo.HOType == Xn_Based_Inter_CU_HO)
12050       {
12051          tgtDuId =  duId;
12052       }
12053
12054       SEARCH_DU_DB(duIdx, tgtDuId, tgtDuDb);
12055       if(tgtDuDb)
12056       {
12057          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
12058           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
12059           * DB */
12060          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
12061          {
12062             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
12063             {
12064                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
12065                break;
12066             }
12067          }
12068
12069          /* If UE context is not found in Target DU, send UE context setup
12070           * request */
12071          if(ueCbInTgtDu == NULLP)
12072          {
12073             if((BuildAndSendUeContextSetupReq(tgtDuId, ueCb)) != ROK)
12074             {
12075                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
12076                return RFAILED;
12077             }
12078          }
12079       }
12080    }
12081
12082 #ifdef START_DL_UL_DATA
12083    startDlData();
12084 #endif
12085
12086    return ROK;
12087 }
12088
12089 /*******************************************************************
12090 *
12091 * @brief processing of F1 setup request
12092 *
12093 * @details
12094 *
12095 *    Function : procF1SetupReq
12096 *
12097 *    Functionality:
12098 *         - processing of  F1 setup request
12099 *
12100 * @params[in] F1AP_PDU_t *f1apMsg
12101 * @return ROK     - success
12102 *         RFAILED - failure
12103 *
12104 * ****************************************************************/
12105 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
12106 {
12107    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
12108    uint32_t duId = 0;
12109    uint64_t nrCellId = 0;
12110    DuDb     *duDb = NULLP;
12111    CuCellCb *cellCb = NULLP;
12112    BIT_STRING_t nrcellIdentity;
12113    F1SetupRequest_t *f1SetupReq = NULLP;
12114    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
12115    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
12116
12117    /* Triggering XN setup request before F1 setup establishment */
12118    if(LOCAL_NODE_TYPE == CLIENT)
12119       BuildAndSendXnSetupReq();
12120
12121    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
12122    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
12123    {
12124       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
12125       {
12126          case ProtocolIE_ID_id_gNB_DU_ID:
12127            {
12128               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
12129               SEARCH_DU_DB(duIdx, duId, duDb);
12130               if(duDb == NULLP)
12131               {
12132                  duDb = &cuCb.duInfo[cuCb.numDu];
12133                  cuCb.numDu++;
12134               }
12135               memset(duDb, 0, sizeof(DuDb));
12136               duDb->duId = duId;
12137               *destDuId = duId;
12138               break;
12139            }
12140          case ProtocolIE_ID_id_gNB_DU_Name:
12141            {
12142               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
12143               break;
12144            }
12145          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
12146            {
12147                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
12148                if(duServedCell->list.array)
12149                {
12150                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
12151                   {
12152                      if(duServedCell->list.array[plmnidx])
12153                      {
12154                         switch(duServedCell->list.array[plmnidx]->id)
12155                         {
12156                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
12157                            {
12158                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
12159                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
12160                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
12161
12162                               bitStringToInt(&nrcellIdentity, &nrCellId);
12163                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
12164                               if(cellCb == NULLP)
12165                               {
12166                                  cellCb = &duDb->cellCb[duDb->numCells];
12167                                  memset(cellCb, 0, sizeof(CuCellCb));
12168                                  cellCb->nrCellId = nrCellId;
12169                                  cellCb->cellStatus = CELL_ACTIVE;
12170                                  duDb->numCells++;
12171                               }
12172                            }
12173                         }
12174                      }
12175                   }
12176                }
12177            }
12178       }
12179    }
12180    if(ret == ROK)
12181    {
12182       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
12183    }
12184    else
12185    {
12186        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
12187    }
12188 }
12189
12190 /****************************************************************
12191 *
12192 * @brief processing of UE Context Release Complete
12193 *
12194 * @details
12195 *
12196 *    Function : procUeContextReleaseComplete
12197 *
12198 *    Functionality:
12199 *         - processing of UE Context Release Complete
12200 *
12201 * @params[in] F1AP_PDU_t *f1apMsg
12202 * @return ROK     - success
12203 *         RFAILED - failure
12204 *
12205 * ****************************************************************/
12206 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
12207 {
12208    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
12209    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
12210    DuDb *duDb = NULLP;
12211    CuUeCb *ueCb = NULLP;
12212    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12213
12214    SEARCH_DU_DB(duIdx, duId, duDb);
12215    if(!duDb)
12216    {
12217       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
12218       return;
12219    }
12220
12221    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12222    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
12223    {
12224       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
12225       {
12226          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12227             {
12228                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12229                break;
12230             }
12231          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12232             {
12233                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12234                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
12235                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
12236                {
12237                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
12238                   {
12239                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
12240                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
12241                      {
12242                         for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
12243                         {
12244                            deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
12245                         }
12246                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
12247                         ueCb->cellCb->numUe--;
12248                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
12249                         {
12250                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
12251                            duDb->numCells--;
12252                         }
12253                         break;
12254                      }
12255                   }
12256                }
12257                memset(ueCb, 0, sizeof(CuUeCb));
12258                duDb->numUe--;
12259                break;
12260             }
12261       }
12262    }
12263 }
12264
12265 /*******************************************************************
12266  *
12267  * @brief Builds the Paging cell list
12268  *
12269  * @details
12270  *
12271  *    Function : BuildPagingCellList
12272  *
12273  *    Functionality: Build the paging cell list
12274  *
12275  * @params[in] PagingCell_list_t  *pagingCelllist,
12276  *
12277  * @return ROK     - success
12278  *         RFAILED - failure
12279  *
12280  * ****************************************************************/
12281 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
12282 {
12283    uint8_t cellIdx =0;
12284    PagingCell_ItemIEs_t *pagingCellItemIes;
12285    PagingCell_Item_t *pagingCellItem;
12286
12287    pagingCelllist->list.count = numCells;
12288    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
12289    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
12290    if(pagingCelllist->list.array == NULLP)
12291    {
12292       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12293       return RFAILED;
12294    }
12295
12296    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12297    {
12298       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12299       if(pagingCelllist->list.array[cellIdx] == NULLP)
12300       {
12301          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12302          return RFAILED;
12303       }
12304    }
12305
12306    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12307    {
12308       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12309       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
12310       pagingCellItemIes->criticality = Criticality_ignore;
12311       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
12312       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12313
12314       /* Fill NrCgi Information */
12315       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
12316    }
12317
12318    return ROK;
12319 }
12320
12321 /*******************************************************************
12322  *
12323  * @brief Deallocation of memory allocated in paging msg
12324  *
12325  * @details
12326  *
12327  *    Function :FreePagingMsg
12328  *
12329  *    Functionality: Deallocation of memory allocated in paging msg
12330  *
12331  * @params[in] F1AP_PDU_t *f1apMsg
12332  *
12333  * @return void
12334  *
12335  * ****************************************************************/
12336 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
12337 {
12338    uint8_t ieIdx, cellIdx;
12339    Paging_t   *paging;
12340    PagingCell_ItemIEs_t *pagingCellItemIes;
12341    PagingCell_Item_t *pagingCellItem;
12342    PagingCell_list_t  *pagingCelllist;
12343
12344    if(f1apMsg)
12345    {
12346       if(f1apMsg->choice.initiatingMessage)
12347       {
12348          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12349          if(paging->protocolIEs.list.array)
12350          {
12351             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
12352             {
12353                if(paging->protocolIEs.list.array[ieIdx])
12354                {
12355                   switch(paging->protocolIEs.list.array[ieIdx]->id)
12356                   {
12357                      case ProtocolIE_ID_id_UEIdentityIndexValue:
12358                      {
12359                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12360                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12361                         break;
12362                      }
12363
12364                      case ProtocolIE_ID_id_PagingIdentity:
12365                      {
12366                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
12367                         {
12368                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12369                            {
12370                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
12371                               {
12372                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12373                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12374                               }
12375                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
12376                                 sizeof(struct CNUEPagingIdentity));
12377                            }
12378                         }
12379                         break;
12380                      }
12381
12382                      case ProtocolIE_ID_id_PagingCell_List:
12383                      {
12384                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
12385                         if(pagingCelllist->list.array)
12386                         {
12387                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12388                            {
12389                               if(pagingCelllist->list.array[cellIdx])
12390                               {
12391                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12392                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
12393                                   {
12394                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12395                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
12396                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
12397                                   }
12398                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12399                               }
12400                            }
12401                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
12402                         }
12403                         break;
12404                      }
12405                   }
12406                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12407                }
12408             }
12409             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12410          }
12411          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12412       }
12413       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12414    }
12415 }
12416 /*******************************************************************
12417  *
12418  * @brief Builds and sends the paging message if UE is in idle mode
12419  *
12420  * @details
12421  *
12422  *    Function : BuildAndSendPagingMsg
12423  *
12424  *    Functionality: Builds and sends the paging message
12425  *
12426  * @params[in] uint32_t duId, uint8_t gsTmsi
12427  *
12428  * @return ROK     - success
12429  *         RFAILED - failure
12430  *
12431  * ****************************************************************/
12432 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
12433 {
12434    bool       memAllocFailed = false;
12435    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
12436    uint16_t   ueId = 0, duIdx = 0;
12437
12438    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
12439     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
12440    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
12441    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
12442
12443    F1AP_PDU_t *f1apMsg = NULLP;
12444    Paging_t   *paging = NULLP;
12445    DuDb       *duDb;
12446    asn_enc_rval_t         encRetVal;
12447
12448    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
12449
12450    SEARCH_DU_DB(duIdx, duId, duDb);
12451    if(duDb == NULLP)
12452    {
12453       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
12454       return ret;
12455    }
12456    if(duDb->numCells == 0)
12457    {
12458       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): No CELL is UP!");
12459       return ret;
12460    }
12461
12462    while(true)
12463    {
12464       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12465       if(f1apMsg == NULLP)
12466       {
12467          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
12468          break;
12469       }
12470
12471       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
12472
12473       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12474       if(f1apMsg->choice.initiatingMessage == NULLP)
12475       {
12476          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
12477          break;
12478       }
12479       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
12480       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12481       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
12482
12483       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12484
12485       elementCnt = 5;
12486       paging->protocolIEs.list.count = elementCnt;
12487       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
12488
12489       /* Initialize the Paging Message members */
12490       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12491       if(paging->protocolIEs.list.array == NULLP)
12492       {
12493          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
12494          break;
12495       }
12496
12497       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12498       {
12499          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12500          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
12501          {
12502             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12503             memAllocFailed = true;
12504             break;
12505          }
12506       }
12507
12508       if(memAllocFailed == true)
12509       {
12510          break;
12511       }
12512
12513       /* UE Identity Index Value */
12514       ieIdx=0;
12515       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
12516       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12517       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
12518       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
12519       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
12520       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12521             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12522       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
12523       {
12524          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12525          break;
12526       }
12527
12528       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
12529       ueId = gsTmsi % 1024;
12530       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
12531
12532       /* Paging Identity */
12533       ieIdx++;
12534       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
12535       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12536       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
12537       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
12538                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
12539       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
12540             sizeof(struct CNUEPagingIdentity));
12541       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12542       {
12543          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12544          break;
12545       }
12546
12547       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
12548                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
12549
12550       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
12551       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12552             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12553       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
12554       {
12555          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12556          break;
12557       }
12558
12559       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
12560             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
12561
12562       /* Paging Drx */
12563       ieIdx++;
12564       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
12565       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12566       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
12567       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
12568
12569       /* Paging Priority */
12570       ieIdx++;
12571       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
12572       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12573       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
12574       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
12575
12576       /* Paging Cell List */
12577       ieIdx++;
12578       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
12579       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12580       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
12581       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
12582       {
12583          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
12584          break;
12585       }
12586
12587       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12588
12589       /* Encode the UE Context Release Command type as APER */
12590       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12591       encBufSize = 0;
12592       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12593             encBuf);
12594
12595       /* Encode results */
12596       if(encRetVal.encoded == ENCODE_FAIL)
12597       {
12598          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
12599                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12600          break;
12601       }
12602       else
12603       {
12604          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
12605          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12606          {
12607             DU_LOG("%x",encBuf[ieIdx]);
12608          }
12609       }
12610
12611       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
12612       {
12613          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
12614          break;
12615       }
12616
12617       ret = ROK;
12618       break;
12619
12620    }
12621
12622    FreePagingMsg(f1apMsg);
12623    return ret;
12624 }
12625
12626 /*******************************************************************
12627  *
12628  * @brief Decode received character string into F1AP message
12629  *
12630  * @details
12631  *
12632  *    Function : F1APMsgHdlr
12633  *
12634  *    Functionality:
12635  *         - Decodes received F1AP control message
12636  *
12637  * @params[in]
12638  * @return ROK     - success
12639  *         RFAILED - failure
12640  *
12641  * ****************************************************************/
12642 uint8_t F1APDecodeMsg(F1AP_PDU_t *f1apMsg, Buffer *mBuf, char **recvBuf, MsgLen *recvBufLen)
12643 {
12644    int i;
12645    MsgLen copyCnt;
12646    asn_dec_rval_t rval; /* Decoder return value */
12647
12648    /* Copy mBuf into char array to decode it */
12649    ODU_GET_MSG_LEN(mBuf, recvBufLen);
12650    CU_ALLOC(*recvBuf, (Size)(*recvBufLen));
12651    if(*recvBuf == NULLP)
12652    {
12653       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12654       return RFAILED;
12655    }
12656    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, *recvBufLen, (Data *)*recvBuf, &copyCnt) != ROK)
12657    {
12658       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12659       return RFAILED;
12660    }
12661
12662    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : \n");
12663    for(i=0; i< *recvBufLen; i++)
12664    {
12665       DU_LOG("%x ",(*recvBuf)[i]);
12666    }
12667
12668    /* Decoding flat buffer into F1AP messsage */
12669    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, *recvBuf, *recvBufLen, 0, 0);
12670    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12671    {
12672       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12673       return RFAILED;
12674    }
12675
12676    /* Printing the decoded F1AP PDU */
12677    DU_LOG("\n");
12678    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12679    return ROK;
12680 }
12681
12682 /*******************************************************************
12683  *
12684  * @brief Handles received F1AP message and sends back response
12685  *
12686  * @details
12687  *
12688  *    Function : F1APMsgHdlr
12689  *
12690  *    Functionality:
12691  *         - Decodes received F1AP control message
12692  *         - Prepares response message, encodes and sends to SCTP
12693  *
12694  * @params[in]
12695  * @return ROK     - success
12696  *         RFAILED - failure
12697  *
12698  * ****************************************************************/
12699 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12700 {
12701    char *recvBuf;
12702    MsgLen recvBufLen;
12703    F1AP_PDU_t *f1apMsg = NULLP;
12704    F1AP_PDU_t f1apasnmsg ;
12705
12706    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12707    ODU_PRINT_MSG(mBuf, 0,0);
12708
12709    f1apMsg = &f1apasnmsg;
12710    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12711    if(F1APDecodeMsg(f1apMsg, mBuf, &recvBuf, &recvBufLen) != ROK)
12712    {
12713       DU_LOG("\nERROR  -->  F1AP : F1AP PDU decode failed");
12714       return;
12715    }
12716
12717    switch(f1apMsg->present)
12718    {
12719       case F1AP_PDU_PR_initiatingMessage:
12720          {
12721             switch(f1apMsg->choice.initiatingMessage->value.present)
12722             {
12723                case InitiatingMessage__value_PR_Reset:
12724                   {
12725                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12726                      BuildAndSendF1ResetAck();
12727                      break;
12728                   }
12729
12730                case InitiatingMessage__value_PR_F1SetupRequest:
12731                   {
12732                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12733                      procF1SetupReq(duId, f1apMsg);
12734                      break;
12735                   }
12736
12737                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12738                   {
12739                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12740                      procGnbDuUpdate(*duId, f1apMsg);
12741                      break;
12742                   }
12743                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12744                   {
12745                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12746                      procInitULRRCMsg(*duId, f1apMsg);
12747                      break;
12748                   }
12749                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12750                   {
12751                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12752                      procUlRrcMsg(*duId, f1apMsg);
12753                      break;
12754                   }
12755
12756                case InitiatingMessage__value_PR_RRCDeliveryReport:
12757                   {
12758                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12759                      break;
12760                   }
12761                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12762                   {
12763                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12764                      procUeContextReleaseReq(*duId, f1apMsg);
12765                      break;
12766                   }
12767                default:
12768                   {
12769                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12770                            f1apMsg->choice.initiatingMessage->value.present);
12771                      return;
12772                   }
12773             }/* End of switch(initiatingMessage) */
12774             break;
12775          }
12776
12777       case F1AP_PDU_PR_successfulOutcome:
12778          {
12779             switch(f1apMsg->choice.successfulOutcome->value.present)
12780             {
12781                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12782                   {
12783                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12784                      break;
12785                   }
12786                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12787                   {
12788                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12789                      procUeContextSetupResponse(*duId, f1apMsg, recvBuf, recvBufLen);
12790                      break;
12791                   }
12792                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12793                   {
12794                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12795                      procUeContextModificationResponse(*duId, f1apMsg, recvBuf, recvBufLen);
12796                      break;
12797                   }
12798                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12799                   {
12800                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12801                       procUeContextReleaseComplete(*duId, f1apMsg);
12802                       break;
12803                   }
12804                default:
12805                   {
12806                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12807                            f1apMsg->choice.successfulOutcome->value.present);
12808                      return;
12809                   }
12810             }/* End of switch(successfulOutcome) */
12811             break;
12812          }
12813       default:
12814          {
12815             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12816             return;
12817          }
12818    }/* End of switch(f1apMsg->present) */
12819
12820    CU_FREE(recvBuf, (Size)(recvBufLen));
12821 } /* End of F1APMsgHdlr */
12822
12823 /**********************************************************************
12824   End of file
12825  **********************************************************************/