src/cu_stub/cu_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "ProtocolIE-Field.h"
  25 #include "ProtocolExtensionField.h"
  26 #include "ProtocolIE-SingleContainer.h"
  27 #include "F1SetupResponse.h"
  28 #include "SuccessfulOutcome.h"
  29 #include "InitiatingMessage.h"
  30 #include "NonDynamic5QIDescriptor.h"
  31 #include "AveragingWindow.h"
  32 #include "MaxDataBurstVolume.h"
  33 #include "Flows-Mapped-To-DRB-Item.h"
  34 #include "SliceSupportItem.h"
  35 #include "ServedPLMNs-Item.h"
  36 #include "F1AP-PDU.h"
  37 #include "ULUPTNLInformation-ToBeSetup-Item.h"
  38 #include "ULConfiguration.h"
  39 #include "ModulationOrder.h"
  40 #include "BandNR.h"
  41 #include "UE-CapabilityRAT-Container.h"
  42 #include "UE-CapabilityRAT-ContainerList.h"
  43 #include "UE-CapabilityRAT-ContainerListRRC.h"
  44 #include "HandoverPreparationInformationRrc-IEs.h"
  45 #include "HandoverPreparationInformationRrc.h"
  46 #include "SupportedBandwidth.h"
  47 #include "FeatureSetUplinkPerCC.h"
  48 #include "FeatureSetDownlinkPerCC.h"
  49 #include "FeatureSets.h"
  50 #include "RF-Parameters.h"
  51 #include "UE-NR-Capability.h"
  52 #include "ProtocolExtensionContainer.h"
  53 #include "CellGroupConfigRrc.h"
  54 #include "MAC-CellGroupConfig.h"
  55 #include "SchedulingRequestConfig.h"
  56 #include "SchedulingRequestToAddMod.h"
  57 #include "BSR-Config.h"
  58 #include "TAG-Config.h"
  59 #include "TAG.h"
  60 #include "PHR-Config.h"
  61 #include "RLC-Config.h"
  62 #include "UL-AM-RLC.h"
  63 #include "DL-AM-RLC.h"
  64 #include "LogicalChannelConfig.h"
  65 #include "RLC-BearerConfig.h"
  66 #include "PhysicalCellGroupConfig.h"
  67 #include "SpCellConfig.h"
  68 #include "ServingCellConfig.h"
  69 #include "ControlResourceSet.h"
  70 #include "SearchSpace.h"
  71 #include "PDCCH-Config.h"
  72 #include "PDSCH-TimeDomainResourceAllocation.h"
  73 #include "PDSCH-TimeDomainResourceAllocationList.h"
  74 #include "DMRS-DownlinkConfig.h"
  75 #include "PDSCH-Config.h"
  76 #include "BWP-DownlinkDedicated.h"
  77 #include "PUSCH-TimeDomainResourceAllocation.h"
  78 #include "PUSCH-TimeDomainResourceAllocationList.h"
  79 #include "DMRS-UplinkConfig.h"
  80 #include "PUSCH-Config.h"
  81 #include "SRS-ResourceId.h"
  82 #include "SRS-Resource.h"
  83 #include "SRS-ResourceSet.h"
  84 #include "SRS-Config.h"
  85 #include "PUCCH-Config.h"
  86 #include "PUCCH-ResourceSet.h"
  87 #include "PUCCH-Resource.h"
  88 #include "PUCCH-format1.h"
  89 #include "PUCCH-FormatConfig.h"
  90 #include "BWP-UplinkDedicated.h"
  91 #include "PUSCH-ServingCellConfig.h"
  92 #include "UplinkConfig.h"
  93 #include "PDSCH-ServingCellConfig.h"
  94 #include "EUTRANQoS.h"
  95 #include "GBR-QosInformation.h"
  96 #include "DRBs-ToBeSetupMod-List.h"
  97 #include "DRBs-ToBeSetupMod-Item.h"
  98 #include "DRBs-Setup-Item.h"
  99 #include "DLUPTNLInformation-ToBeSetup-List.h"
 100 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 101 #include "UPTransportLayerInformation.h"
 102 #include "GTPTunnel.h"
 103 #include "QoSInformation.h"
 104 #include "Cells-to-be-Activated-List.h"
 105 #include "DL-CCCH-Message.h"
 106 #include "SRB-ToAddModList.h"
 107 #include "SRB-ToAddMod.h"
 108 #include "RRCSetup-IEs.h"
 109 #include "RRCSetup.h"
 110 #include "DL-DCCH-Message.h"
 111 #include "RRCReconfiguration-IEs.h"
 112 #include "RRCReconfiguration.h"
 113 #include "DRB-ToAddModList.h"
 114 #include "DRB-ToAddMod.h"
 115 #include "SDAP-Config.h"
 116 #include "SSB-MTC.h"
 117 #include "MeasTiming.h"
 118 #include "MeasTimingList.h"
 119 #include "MeasurementTimingConfigurationRrc-IEs.h"
 120 #include "MeasurementTimingConfigurationRrc.h"
 121 #include "PDCP-Config.h"
 122 #include "RSRP-Range.h"
 123 #include "RSRQ-Range.h"
 124 #include "SINR-Range.h"
 125 #include "ThresholdNR.h"
 126 #include "MeasObjectToAddMod.h"
 127 #include "MeasObjectNR.h"
 128 #include "MeasObjectToAddModList.h"
 129 #include "EventTriggerConfig.h"
 130 #include "ReportConfigNR.h"
 131 #include "ReportConfigToAddMod.h"
 132 #include "ReportConfigToAddModList.h"
 133 #include "MeasIdToAddMod.h"
 134 #include "MeasIdToAddModList.h"
 135 #include "FilterCoefficient.h"
 136 #include "QuantityConfigNR.h"
 137 #include "QuantityConfig.h"
 138 #include "MeasConfigRrc.h"
 139 #include "AS-Config.h"
 140 #include "RRCReconfiguration-v1530-IEs.h"
 141 #include "CNUEPagingIdentity.h"
 142 #include "PagingCell-Item.h"
 143 #include "UL-DCCH-Message.h"
 144 #include "DRX-ConfigRrc.h"
 145
 146 #include "cu_stub_sctp.h"
 147 #include "cu_stub_egtp.h"
 148 #include "cu_f1ap_msg_hdl.h"
 149 #include "cu_stub.h"
 150
 151 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 152 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 153
 154 /*******************************************************************
 155  *
 156  * @brief Sends F1 msg over SCTP
 157  *
 158  * @details
 159  *
 160  *    Function : SendF1APMsg
 161  *
 162  *    Functionality: Sends F1 msg over SCTP
 163  *
 164  * @params[in] Region region
 165  *             Pool pool
 166  * @return ROK     - success
 167  *         RFAILED - failure
 168  *
 169  * ****************************************************************/
 170 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 171 {
 172    Buffer *mBuf = NULLP;
 173
 174    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 175    {
 176       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 177       {
 178          ODU_PRINT_MSG(mBuf, 0,0);
 179
 180          if(sctpSend(duId, mBuf) != ROK)
 181          {
 182             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 183             ODU_PUT_MSG_BUF(mBuf);
 184             return RFAILED;
 185          }
 186       }
 187       else
 188       {
 189          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 190          ODU_PUT_MSG_BUF(mBuf);
 191          return RFAILED;
 192       }
 193       ODU_PUT_MSG_BUF(mBuf);
 194    }
 195    else
 196    {
 197       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 198       return RFAILED;
 199    }
 200
 201    return ROK;
 202 } /* SendF1APMsg */
 203
 204 /********************************************************************
 205  *
 206  * @brief Builds and sends the F1SetupResponse
 207  *
 208  * @details
 209  *
 210  *    Function : BuildAndSendF1SetupRsp
 211  *
 212  *    Functionality: Constructs the F1SetupResponse message and sends
 213  *                   it back to the DU through SCTP.
 214  *
 215  * @params[in] void **buf,Buffer to which encoded pattern is written into
 216  * @params[in] int *size,size of buffer
 217  *
 218  * @return ROK     - success
 219  *         RFAILED - failure
 220  *
 221  * ****************************************************************/
 222 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 223 {
 224    uint8_t    idx,ieIdx;
 225    uint8_t    elementCnt,cellCnt;
 226    F1AP_PDU_t         *f1apMsg = NULL;
 227    F1SetupResponse_t  *f1SetupRsp = NULL;
 228    GNB_CU_Name_t      *cuName = NULL;
 229    Cells_to_be_Activated_List_t *cellToActivate;
 230    RRC_Version_t      *rrcVer = NULL;
 231    asn_enc_rval_t     encRetVal;
 232    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 233
 234    /* Allocate the memory for F1SetupRequest_t */
 235    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 236    if(f1apMsg == NULLP)
 237    {
 238       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 239       return RFAILED;
 240    }
 241    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 242
 243    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 244    if(f1apMsg->choice.successfulOutcome == NULLP)
 245    {
 246       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 247       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 248       return RFAILED;
 249    }
 250
 251    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 252    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 253    f1apMsg->choice.successfulOutcome->value.present = \
 254                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 255    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 256
 257    elementCnt = 3;
 258    f1SetupRsp->protocolIEs.list.count = elementCnt;
 259    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 260
 261    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 262          elementCnt * sizeof(F1SetupResponseIEs_t *));
 263    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 264    {
 265       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 266       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 267       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 268       return RFAILED;
 269    }
 270
 271    for(idx=0; idx<elementCnt; idx++)
 272    {
 273       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 274             sizeof(F1SetupResponseIEs_t));
 275       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 276       {
 277          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 278                elementCnt * sizeof(F1SetupResponseIEs_t *));
 279          CU_FREE(f1apMsg->choice.successfulOutcome, \
 280                sizeof(SuccessfulOutcome_t));
 281          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 282          return RFAILED;
 283       }
 284    }
 285
 286    /*TransactionID*/
 287    idx = 0;
 288    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 289    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 290    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 291                                                             F1SetupResponseIEs__value_PR_TransactionID;
 292    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 293                                                                         TRANS_ID;
 294 #if 0
 295    /* CU name IE is of type printableString_t which wireshark is unable to decode.
 296     * However this string is decoded successfully on online decoders.
 297     * Since this is an optional IE and the value received in it are not
 298     * used as of now, eliminating this IE for now to avoid wireshark error.
 299     */
 300    /*CU Name*/
 301    idx++;
 302    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 303    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 304    f1SetupRsp->protocolIEs.list.array[idx]->value.present = F1SetupResponseIEs__value_PR_GNB_CU_Name;
 305    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 306    cuName->size = strlen((char *)cuCb.cuCfgParams.cuName);
 307
 308    CU_ALLOC(cuName->buf, cuName->size);
 309    if(cuName->buf == NULLP)
 310    {
 311       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 312       {
 313          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 314       }
 315       CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 316       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 317       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 318       return RFAILED;
 319    }
 320    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 321 #endif
 322
 323    /*Cells to be activated list*/
 324    idx++;
 325    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 326    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 327    f1SetupRsp->protocolIEs.list.array[idx]->value.present = F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 328    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.Cells_to_be_Activated_List;
 329
 330    cellCnt=1;
 331    cellToActivate->list.count = cellCnt;
 332    cellToActivate->list.size = cellCnt * sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 333    CU_ALLOC(cellToActivate->list.array, sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 334    if(cellToActivate->list.array == NULLP)
 335    {
 336       CU_FREE(cuName->buf, sizeof(cuName->size));
 337       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 338       {
 339          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 340       }
 341       CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 342       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 343       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 344       return RFAILED;
 345    }
 346    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 347    {
 348       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 349       if(cellToActivate->list.array[ieIdx] == NULLP)
 350       {
 351          CU_FREE(cellToActivate->list.array, sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 352          CU_FREE(cuName->buf, sizeof(cuName->size));
 353          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 354          {
 355             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 356          }
 357          CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 358          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 359          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 360          return RFAILED;
 361       }
 362    }
 363    cellToActivate->list.array[0]->id = \
 364                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 365    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 366    cellToActivate->list.array[0]->value.present = \
 367                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 368    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 369       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 370    CU_ALLOC(cellToActivate->list.array[0]->\
 371          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 372          3*sizeof(uint8_t));
 373    if(cellToActivate->list.array[0]->value.choice.\
 374          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 375    {
 376
 377       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 378       {
 379          CU_FREE(cellToActivate->list.array[ieIdx],\
 380                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 381       }
 382
 383       CU_FREE(cellToActivate->list.array,\
 384             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 385       CU_FREE(cuName->buf, sizeof(cuName->size));
 386       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 387       {
 388          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 389                sizeof(F1SetupResponseIEs_t));
 390       }
 391       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 392             elementCnt * sizeof(F1SetupResponseIEs_t *));
 393       CU_FREE(f1apMsg->choice.successfulOutcome, \
 394             sizeof(SuccessfulOutcome_t));
 395       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 396       return RFAILED;
 397    }
 398    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 399          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 400    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 401       nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
 402    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 403          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 404          cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 405          nRCGI.nRCellIdentity.size);
 406    if(cellToActivate->list.array[0]->value.choice.\
 407          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 408    {
 409       CU_FREE(cellToActivate->list.array[0]->\
 410             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 411             3*sizeof(uint8_t));
 412       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 413       {
 414          CU_FREE(cellToActivate->list.array[ieIdx],\
 415                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 416       }
 417
 418       CU_FREE(cellToActivate->list.array,\
 419             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 420       CU_FREE(cuName->buf, sizeof(cuName->size));
 421       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 422       {
 423          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 424                sizeof(F1SetupResponseIEs_t));
 425       }
 426       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 427             elementCnt * sizeof(F1SetupResponseIEs_t *));
 428       CU_FREE(f1apMsg->choice.successfulOutcome, \
 429             sizeof(SuccessfulOutcome_t));
 430       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 431       return RFAILED;
 432    }
 433    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 434
 435    /* RRC Version */
 436    idx++;
 437    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 438                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 439    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 440    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 441                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 442    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 443    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 444
 445    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 446    if(rrcVer->latest_RRC_Version.buf == NULLP)
 447    {
 448       CU_FREE(cuName->buf, sizeof(cuName->size));
 449       for(ieIdx=0; ieIdx<elementCnt; idx++)
 450       {
 451          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 452                sizeof(F1SetupResponseIEs_t));
 453       }
 454       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 455             elementCnt * sizeof(F1SetupResponseIEs_t *));
 456       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 457       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 458       return RFAILED;
 459    }
 460
 461    /* Need to check RRC Version */
 462    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 463    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 464    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 465    if(rrcVer->iE_Extensions == NULLP)
 466    {
 467       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 468       CU_FREE(cuName->buf, sizeof(cuName->size));
 469       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 470       {
 471          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 472                sizeof(F1SetupResponseIEs_t));
 473       }
 474       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 475             elementCnt * sizeof(F1SetupResponseIEs_t *));
 476       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 477       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 478       return RFAILED;
 479    }
 480    rrcVer->iE_Extensions->list.count = 1;
 481    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 482    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 483          sizeof(struct RRC_Version_ExtIEs *));
 484    if(rrcVer->iE_Extensions->list.array == NULLP)
 485    {
 486       CU_FREE(rrcVer->iE_Extensions,\
 487             sizeof(ProtocolExtensionContainer_4624P81_t));
 488       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 489       CU_FREE(cuName->buf, sizeof(cuName->size));
 490       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 491       {
 492          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 493                sizeof(F1SetupResponseIEs_t));
 494       }
 495       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 496             elementCnt * sizeof(F1SetupResponseIEs_t *));
 497       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 498       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 499       return RFAILED;
 500    }
 501    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 502          sizeof(struct RRC_Version_ExtIEs));
 503    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 504    {
 505       CU_FREE(rrcVer->iE_Extensions->list.array,\
 506             sizeof(struct RRC_Version_ExtIEs *));
 507       CU_FREE(rrcVer->iE_Extensions,\
 508             sizeof(ProtocolExtensionContainer_4624P81_t));
 509       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 510       CU_FREE(cuName->buf, sizeof(cuName->size));
 511       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 512       {
 513          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 514                sizeof(F1SetupResponseIEs_t));
 515       }
 516       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 517             elementCnt * sizeof(F1SetupResponseIEs_t *));
 518       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 519       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 520       return RFAILED;
 521    }
 522    rrcVer->iE_Extensions->list.array[0]->id = \
 523                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 524    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 525    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 526                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 527    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 528       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 529    CU_ALLOC(rrcVer->iE_Extensions->list.\
 530          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 531          3*sizeof(uint8_t));
 532    if(rrcVer->iE_Extensions->list.\
 533          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 534    {
 535       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 536             sizeof(struct RRC_Version_ExtIEs));
 537       CU_FREE(rrcVer->iE_Extensions->list.array,\
 538             sizeof(struct RRC_Version_ExtIEs *));
 539       CU_FREE(rrcVer->iE_Extensions,\
 540             sizeof(ProtocolExtensionContainer_4624P81_t));
 541       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 542       CU_FREE(cuName->buf, sizeof(cuName->size));
 543       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 544       {
 545          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 546                sizeof(F1SetupResponseIEs_t));
 547       }
 548       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 549             elementCnt * sizeof(F1SetupResponseIEs_t *));
 550       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 551       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 552       return RFAILED;
 553    }
 554    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 555       Latest_RRC_Version_Enhanced.buf[0] = 0;
 556    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 557       Latest_RRC_Version_Enhanced.buf[1] = 5;
 558    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 559       Latest_RRC_Version_Enhanced.buf[2] = 15;
 560
 561    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 562
 563    /* Encode the F1SetupRequest type as UPER */
 564    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 565    encBufSize = 0;
 566    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 567
 568    /* Clean up */
 569    if(rrcVer)
 570       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 571    if(cuName)
 572       CU_FREE(cuName->buf, cuName->size);
 573    for(idx=0; idx<elementCnt; idx++)
 574    {
 575       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 576    }
 577    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 578    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 579    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 580
 581    /* Check encode results */
 582    if(encRetVal.encoded == ENCODE_FAIL)
 583    {
 584       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 585             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 586       return RFAILED;
 587    }
 588    else
 589    {
 590       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 591       for(int i=0; i< encBufSize; i++)
 592       {
 593          DU_LOG("%x",encBuf[i]);
 594       }
 595    }
 596
 597    /* Sending msg */
 598    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 599    {
 600       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 601       return RFAILED;
 602    }
 603
 604    return ROK;
 605 }/* End of BuildAndSendF1SetupRsp */
 606
 607 /*******************************************************************
 608  *
 609  * @brief Builds and sends the DUUpdateAcknowledge
 610  *
 611  * @details
 612  *
 613  *    Function : BuildAndSendDUUpdateAck
 614  *
 615  *    Functionality: Constructs the DU Update Acknowledge message and sends
 616  *                   it to the DU through SCTP.
 617  *
 618  * @params[in]
 619  *
 620  * @return ROK     - success
 621  *         RFAILED - failure
 622  *
 623  * ****************************************************************/
 624
 625 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 626 {
 627    uint8_t   idx;
 628    uint8_t   elementCnt;
 629    F1AP_PDU_t *f1apMsg = NULL;
 630    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 631    asn_enc_rval_t enRetVal; /* Encoder return value */
 632
 633    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 634
 635    /* Allocate the memory for F1SetupRequest_t */
 636    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 637    if(f1apMsg == NULLP)
 638    {
 639       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 640       return RFAILED;
 641    }
 642
 643    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 644
 645    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 646    if(f1apMsg->choice.successfulOutcome == NULLP)
 647    {
 648       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 649       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 650       return RFAILED;
 651    }
 652
 653    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 654    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 655    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 656    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 657
 658    elementCnt = 1;
 659    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 660    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 661
 662    /* Initialize the F1Setup members */
 663    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 664    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 665    {
 666       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 667       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 668       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 669       return RFAILED;
 670    }
 671
 672    for(idx=0; idx<elementCnt; idx++)
 673    {
 674       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 675       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 676       {
 677          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 678          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 679          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 680          return RFAILED;
 681       }
 682    }
 683
 684    /*TransactionID*/
 685    idx = 0;
 686    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 687    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 688    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 689    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 690    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 691
 692    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 693
 694    /* Encode the F1SetupRequest type as UPER */
 695    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 696    encBufSize = 0;
 697    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 698
 699    /* Clean up */
 700    for(idx=0; idx<elementCnt; idx++)
 701    {
 702       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 703    }
 704    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 705    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 706    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 707
 708    /* Checking encode results */
 709    if(enRetVal.encoded == ENCODE_FAIL)
 710    {
 711       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 712       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 713       return RFAILED;
 714    }
 715    else
 716    {
 717       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 718       for(int i=0; i< encBufSize; i++)
 719       {
 720          DU_LOG("%x",encBuf[i]);
 721       }
 722    }
 723
 724    /* Sending msg */
 725    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 726    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 727    {
 728       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 729       return RFAILED;
 730    }
 731
 732    return ROK;
 733
 734 }/* End of BuildAndSendDUUpdateAck*/
 735
 736 /*******************************************************************
 737 *
 738 * @brief deallocating the memory of  F1reset msg
 739 *
 740 * @details
 741 *
 742 *    Function : FreeF1ResetReq
 743 *
 744 *    Functionality :
 745 *         - freeing memory of F1reset request msg
 746 *
 747 * @params[in]
 748 * @return void
 749 *
 750 *
 751 * ****************************************************************/
 752 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 753 {
 754    uint8_t idx = 0;
 755    Reset_t *f1ResetMsg = NULLP;
 756
 757    if(f1apMsg)
 758    {
 759       if(f1apMsg->choice.initiatingMessage)
 760       {
 761          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 762          if(f1ResetMsg->protocolIEs.list.array)
 763          {
 764             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 765             {
 766                if(f1ResetMsg->protocolIEs.list.array[idx])
 767                {
 768                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 769                }
 770             }
 771             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 772          }
 773          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 774       }
 775       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 776    }
 777 }
 778 /*******************************************************************
 779  *
 780  * @brief build ansld ans send f1reset msg
 781  *
 782  * @details
 783  *
 784  *    Function : BuildAndSendF1ResetReq
 785  *
 786  *    Functionality: build and send f1reset msg
 787  *
 788  * @return ROK     - success
 789  *         RFAILED - failure
 790  *
 791  * ****************************************************************/
 792 uint8_t BuildAndSendF1ResetReq()
 793 {
 794    uint8_t          elementCnt=0;
 795    uint8_t          idx=0;
 796    uint8_t          ret= RFAILED;
 797    Reset_t          *f1ResetMsg = NULLP;
 798    F1AP_PDU_t       *f1apMsg = NULLP;
 799    asn_enc_rval_t   encRetVal;
 800    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 801    do
 802    {
 803       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 804       if(f1apMsg == NULLP)
 805       {
 806          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 807          break;
 808       }
 809       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 810       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 811       if(f1apMsg->choice.initiatingMessage == NULLP)
 812       {
 813          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 814          break;
 815       }
 816       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 817       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 818       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 819
 820       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 821
 822       elementCnt = 3;
 823       f1ResetMsg->protocolIEs.list.count = elementCnt;
 824       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 825
 826       /* Initialize the F1Reset members */
 827       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 828       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 829       {
 830          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 831          break;
 832       }
 833       for(idx=0; idx<elementCnt; idx++)
 834       {
 835          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 836          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 837          {
 838             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 839             break;
 840          }
 841       }
 842
 843       /*TransactionID*/
 844       idx=0;
 845       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 846       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 847       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 848       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 849
 850       /*Cause*/
 851       idx++;
 852       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 853       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 854       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 855       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 856       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 857
 858       /*Reset Type*/
 859       idx++;
 860       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 861       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 862       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 863       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 864       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 865
 866       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 867
 868       /* Encode the F1SetupRequest type as APER */
 869       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 870       encBufSize = 0;
 871       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 872             encBuf);
 873
 874       /* Encode results */
 875       if(encRetVal.encoded == ENCODE_FAIL)
 876       {
 877          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 878                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 879          break;
 880       }
 881       else
 882       {
 883          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 884          for(idx=0; idx< encBufSize; idx++)
 885          {
 886             DU_LOG("%x",encBuf[idx]);
 887          }
 888       }
 889
 890       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 891       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 892       {
 893          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 894          break;
 895       }
 896
 897       ret = ROK;
 898       break;
 899    }while(true);
 900
 901    FreeF1ResetReq(f1apMsg);
 902    return ret;
 903 }
 904
 905 /*******************************************************************
 906  *
 907  * @brief Fills Radio Bearer Config
 908  *
 909  * @details
 910  *
 911  *    Function : fillSrbCfg
 912  *
 913  *    Functionality: Fills Radio Bearer Config
 914  *
 915  * @params[in] SRB_ToAddModList *
 916  *
 917  * @return ROK     - success
 918  *         RFAILED - failure
 919  *
 920  * ****************************************************************/
 921 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 922 {
 923    uint8_t elementCnt = 0;
 924    uint8_t idx, ieId, srbIdx = 0;
 925
 926    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 927    {
 928       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 929          elementCnt++;
 930    }
 931
 932    if(bearerCfg != NULLP)
 933    {
 934       bearerCfg->list.count = elementCnt;
 935       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 936       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 937       if(bearerCfg->list.array != NULLP)
 938       {
 939          for(idx = 0; idx < elementCnt; idx++)
 940          {
 941             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 942             if(bearerCfg->list.array[idx] == NULLP)
 943             {
 944                for(ieId = 0; ieId < idx; ieId++)
 945                {
 946                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 947                }
 948                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 949                return RFAILED;
 950             }
 951          }
 952       }
 953       else
 954       {
 955          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 956          return RFAILED;
 957       }
 958
 959       idx = 0;
 960       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 961       {
 962          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 963             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 964       }
 965    }
 966    return ROK;
 967 }
 968
 969 /*******************************************************************
 970  *
 971  * @brief Fills Master CellGroup Info
 972  *
 973  * @details
 974  *
 975  *    Function : fillMasterCellGroup
 976  *
 977  *    Functionality: Fills Master Cell Group IE
 978  *
 979  * @params[in] RRCSetup_IEs_t *
 980  *
 981  * @return ROK     - success
 982  *         RFAILED - failure
 983  *
 984  * ****************************************************************/
 985
 986 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 987 {
 988    uint8_t ret = ROK;
 989    masterCellGroup->buf = NULLP;
 990    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 991    {
 992       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 993       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 994       if(masterCellGroup->buf != NULLP)
 995       {
 996          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
 997       }
 998       else
 999       {
1000          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
1001          ret = RFAILED;
1002       }
1003    }
1004    else
1005    {
1006       ret =  RFAILED;
1007    }
1008    return ret;
1009 }
1010
1011 /*******************************************************************
1012  *
1013  * @brief Fills RRC setup IE
1014  *
1015  * @details
1016  *
1017  *    Function : fillRRCSetupIE
1018  *
1019  *    Functionality: Fills RRC Setup IE
1020  *
1021  * @params[in] RRCSetup_IEs_t *
1022  *
1023  * @return ROK     - success
1024  *         RFAILED - failure
1025  *
1026  * ****************************************************************/
1027
1028 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1029 {
1030    uint8_t ret = ROK, srbIdx = 0;
1031    if(rrcSetupIE)
1032    {
1033       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1034       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1035       {
1036          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1037       }
1038       if(ret == ROK)
1039       {
1040          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1041       }
1042       else
1043       {
1044          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1045          ret = RFAILED;
1046       }
1047
1048       /* If SRB configuration are filled successfully in RRC Setup, mark these
1049        * configurartion as sent to UE */
1050       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1051       {
1052          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1053             ueCb->srbList[srbIdx].cfgSentToUe = true;
1054       }
1055    }
1056    return ret;
1057 }
1058 /*******************************************************************
1059  *
1060  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1061  *
1062  * @details
1063  *
1064  *    Function : fillDlCcchRrcMsg
1065  *
1066  *    Functionality: Fills DL DCCCH Message required for
1067  *                   DLRRCMessageTransfer
1068  *
1069  * @params[in] RRCContainer_t *rrcContainer
1070  *
1071  * @return ROK     - success
1072  *         RFAILED - failure
1073  *
1074  * ****************************************************************/
1075
1076 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1077 {
1078    uint8_t ret = ROK;
1079    uint16_t idx2;
1080    DL_CCCH_Message_t dl_CCCH_Msg;
1081    asn_enc_rval_t    encRetVal;
1082
1083    if(rrcContainer != NULLP)
1084    {
1085       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1086
1087       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1088       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1089       {
1090          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1091          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1092          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1093          {
1094             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1095             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1096                RRCSetup__criticalExtensions_PR_rrcSetup;
1097
1098             /* Fill RRC Setup IE */
1099             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1100                sizeof(RRCSetup_IEs_t));
1101             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1102             {
1103                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1104
1105                if(ret == ROK)
1106                {
1107                   /* encode DL-CCCH message into RRC Container */
1108                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1109                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1110                   encBufSize = 0;
1111                   encRetVal = uper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1112                   /* Encode results */
1113                   if(encRetVal.encoded == ENCODE_FAIL)
1114                   {
1115                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1116                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1117                      return RFAILED;
1118                   }
1119                   else
1120                   {
1121                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1122                      for(int i = 0; i< encBufSize; i++)
1123                      {
1124                         DU_LOG("%x",encBuf[i]);
1125                      }
1126                      rrcContainer->size = encBufSize;
1127                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1128                      if(rrcContainer->buf != NULLP)
1129                      {
1130                         memset(rrcContainer->buf, 0, encBufSize);
1131                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1132                         {
1133                            rrcContainer->buf[idx2] =    encBuf[idx2];
1134                         }
1135                      }
1136                   }
1137                }
1138                else
1139                {
1140                   ret = RFAILED;
1141                }
1142             }
1143             else
1144             {
1145                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1146                ret = RFAILED;
1147             }
1148          }
1149          else
1150          {
1151             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1152             ret = RFAILED;
1153          }
1154       }
1155       else
1156       {
1157          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1158          ret = RFAILED;
1159       }
1160    }
1161    else
1162    {
1163       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1164       ret = RFAILED;
1165    }
1166 }
1167
1168 /*******************************************************************
1169  *
1170  * @brief Fills QOS flow configuration
1171  *
1172  * @details
1173  *
1174  *    Function : fillQosFlowsToAdd
1175  *
1176  *    Functionality: Fills QOS flow configuration
1177  *
1178  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1179  *
1180  * @return ROK     - success
1181  *         RFAILED - failure
1182  *
1183  * ****************************************************************/
1184 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1185 {
1186    uint8_t idx, ied, elementCnt;
1187
1188    elementCnt = 1;
1189    qosFlow->list.count = elementCnt;
1190    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1191    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1192    if(qosFlow->list.array != NULLP)
1193    {
1194       for(idx = 0; idx < elementCnt; idx++)
1195       {
1196          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1197          if(qosFlow->list.array[idx] == NULLP)
1198          {
1199             for(ied = 0; ied < idx; ied++)
1200             {
1201                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1202             }
1203             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1204             return RFAILED;
1205          }
1206       }
1207    }
1208    idx = 0;
1209    *qosFlow->list.array[idx] = 9;
1210    return ROK;
1211 }
1212
1213 /*******************************************************************
1214  *
1215  * @brief Fills CN Assoc for Drb to Add/Mod List
1216  *
1217  * @details
1218  *
1219  *    Function : fillCnAssoc
1220  *
1221  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1222  *
1223  * @params[in] struct DRB_ToAddMod__cnAssociation *
1224  *
1225  * @return ROK     - success
1226  *         RFAILED - failure
1227  *
1228  * ****************************************************************/
1229
1230 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1231 {
1232    uint8_t ret = ROK;
1233
1234    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1235    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1236    {
1237       cnAssoc->choice.eps_BearerIdentity = 5;
1238    }
1239    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1240    {
1241       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1242       if(cnAssoc->choice.sdap_Config)
1243       {
1244          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1245          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1246          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1247          cnAssoc->choice.sdap_Config->defaultDRB = true;
1248          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1249          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1250          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1251                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1252          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1253          {
1254             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1255          }
1256          else
1257          {
1258             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1259             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1260             ret = RFAILED;
1261          }
1262       }
1263       else
1264       {
1265          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1266          ret = RFAILED;
1267       }
1268    }
1269    return ret;
1270 }
1271
1272 /*******************************************************************
1273  *
1274  * @brief Fills Radio Bearer Config for Drb
1275  *
1276  * @details
1277  *
1278  *    Function : fillDrbCfg
1279  *
1280  *    Functionality: Fills Radio Bearer Config for Drb
1281  *
1282  * @params[in] drbId, DRB_ToAddModList *
1283  *
1284  * @return ROK     - success
1285  *         RFAILED - failure
1286  *
1287  * ****************************************************************/
1288 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1289 {
1290    uint8_t idx, ied, ret, elementCnt;
1291
1292    ret = ROK;
1293    if(drbCfg != NULLP)
1294    {
1295       elementCnt = 1;
1296       drbCfg->list.count = elementCnt;
1297       drbCfg->list.size =\
1298                          elementCnt * sizeof(DRB_ToAddMod_t *);
1299       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1300       if(drbCfg->list.array != NULLP)
1301       {
1302          for(idx = 0; idx < elementCnt; idx++)
1303          {
1304             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1305             if(drbCfg->list.array[idx] == NULLP)
1306             {
1307                for(ied = 0; ied < idx; ied++)
1308                {
1309                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1310                }
1311                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1312                return RFAILED;
1313             }
1314          }
1315       }
1316       else
1317       {
1318          return RFAILED;
1319       }
1320       idx = 0;
1321       /* CN ASSOCIATION */
1322       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1323       if(drbCfg->list.array[idx]->cnAssociation)
1324       {
1325          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1326       }
1327       /* DRB */
1328       drbCfg->list.array[idx]->drb_Identity = drbId;
1329    }
1330    return ret;
1331 }
1332
1333 /*******************************************************************
1334  *
1335  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1336  *
1337  * @details
1338  *
1339  *    Function : fillRrcReconfigIE
1340  *
1341  *    Functionality: Fills RRC Reconfig Message required for
1342  *                   DLRRCMessageTransfer
1343  *
1344  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1345  *
1346  * @return ROK     - success
1347  *         RFAILED - failure
1348  *
1349  * ****************************************************************/
1350
1351 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1352 {
1353    uint8_t ret = ROK;
1354    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1355    if(rrcReconfigMsg->radioBearerConfig)
1356    {
1357       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1358       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1359       {
1360          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1361
1362       }
1363       if(ret == ROK)
1364       {
1365          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1366          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1367          {
1368             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1369             if(ret == RFAILED)
1370             {
1371                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1372                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1373                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1374             }
1375          }
1376       }
1377       else
1378       {
1379          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1380          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1381       }
1382    }
1383
1384    return ret;
1385 }
1386 /*******************************************************************
1387  *
1388  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1389  *
1390  * @details
1391  *
1392  *    Function : fillDlDcchRrcMsg
1393  *
1394  *    Functionality: Fills DL DCCH Message required for
1395  *                   DLRRCMessageTransfer
1396  *
1397  * @params[in] RRCContainer_t *rrcContainer
1398  *
1399  * @return ROK     - success
1400  *         RFAILED - failure
1401  *
1402  * ****************************************************************/
1403
1404 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer, bool updateAllRbCfg)
1405 {
1406    uint8_t ret = ROK;
1407    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1408    DL_DCCH_Message_t dl_DCCH_Msg;
1409    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1410    asn_enc_rval_t        encRetVal;
1411
1412    if(rrcContainer != NULLP)
1413    {
1414       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1415
1416       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1417       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1418       {
1419          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1420          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1421          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1422          {
1423             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1424             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, updateAllRbCfg);
1425             if(ret == ROK)
1426             {
1427                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1428                 * configurartion as sent to UE */
1429                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1430                {
1431                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1432                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1433                }
1434                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1435                {
1436                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1437                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1438                }
1439
1440                /* encode DL-DCCH message into RRC Container */
1441                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1442                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1443                encBufSize = 0;
1444                encRetVal = uper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1445                /* Encode results */
1446                if(encRetVal.encoded == ENCODE_FAIL)
1447                {
1448                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1449                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1450                   return RFAILED;
1451                }
1452                else
1453                {
1454                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1455                   for(int i = 0; i< encBufSize; i++)
1456                   {
1457                      DU_LOG("%x",encBuf[i]);
1458                   }
1459                   rrcContainer->size = encBufSize;
1460                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1461                   if(rrcContainer->buf != NULLP)
1462                   {
1463                      memset(rrcContainer->buf, 0, encBufSize);
1464                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1465                      {
1466                         rrcContainer->buf[idx2] =       encBuf[idx2];
1467                      }
1468                   }
1469                }
1470             }
1471          }
1472          else
1473          {
1474             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1475             ret = RFAILED;
1476          }
1477       }
1478       else
1479       {
1480          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1481          ret = RFAILED;
1482       }
1483    }
1484    else
1485    {
1486       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1487       ret = RFAILED;
1488    }
1489    return ret;
1490 }
1491
1492 /*******************************************************************
1493  *
1494  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1495  *
1496  * @details
1497  *
1498  *    Function : BuildDLRRCContainer
1499  *
1500  *    Functionality: Builds RRC Container IE required for
1501  *                   DLRRCMessageTransfer
1502  *
1503  * @params[in]
1504  *
1505  * @return ROK     - success
1506  *         RFAILED - failure
1507  *
1508  * ****************************************************************/
1509
1510 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1511 {
1512    uint8_t ret, bufLen;
1513
1514    ret =ROK;
1515    if(rrcMsgType == RRC_SETUP)
1516    {
1517       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1518       if(ret == RFAILED)
1519          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1520    }
1521    else if(rrcMsgType == RRC_SETUP_COMPLETE)
1522    {
1523       DU_LOG("\nINFO --> F1AP : Sending NAS Authentication Request");
1524       char authReqBuf[51] = {0x00, ueCb->pdcpSn++, 0x2a, 0x85, 0x4f, 0xc0, 0x0a, 0xc0, 0x40, 0x40, 0x00, 0x04, 0x2f, 0x58, 0x39, 0x12,\
1525                              0x37, 0x15, 0x74, 0x16, 0x4c, 0x8d, 0xd3, 0x95, 0xa6, 0x9e, 0x94, 0x03, 0x24, 0x02, 0x00, 0x6f,\
1526                              0x0b, 0x39, 0x5e, 0xbc, 0xb0, 0x00, 0x1a, 0xb1, 0xc1, 0x3f, 0x84, 0x4f, 0x77, 0xe3, 0x20, 0x00,\
1527                              0x00, 0x00, 0x00};
1528       bufLen = 51;
1529       rrcContainer->size = bufLen;
1530       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1531       if(rrcContainer->buf != NULLP)
1532       {
1533          memset(rrcContainer->buf, 0, bufLen);
1534          memcpy(rrcContainer->buf, authReqBuf, bufLen);
1535       }
1536       else
1537       {
1538          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1539          ret = RFAILED;
1540
1541       }
1542    }
1543    else if(rrcMsgType == NAS_AUTHENTICATION_RSP)
1544    {
1545       DU_LOG("\nINFO --> F1AP : Sending NAS Security mode command");
1546       char secModeBuf[30]={0x00, ueCb->pdcpSn++, 0x2e, 0x82, 0xaf, 0xc0, 0x7d, 0x1c, 0x4e, 0xfc, 0x80, 0x0f, 0xc0,
1547                           0x0b, 0xa0, 0x20, 0x40, 0x9e, 0x0e, 0x1e, 0x0e, 0x1c, 0x26, 0xc0, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00};
1548       bufLen =30;
1549       rrcContainer->size = bufLen;
1550       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1551       if(rrcContainer->buf != NULLP)
1552       {
1553          memset(rrcContainer->buf, 0, bufLen);
1554          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1555       }
1556       else
1557       {
1558          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1559          ret = RFAILED;
1560       }
1561    }
1562    else if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
1563    {
1564       DU_LOG("\nINFO --> F1AP : Sending RRC Security mode command");
1565       char secModeBuf[9]={0x00, ueCb->pdcpSn++, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1566       bufLen =9;
1567       rrcContainer->size = bufLen;
1568       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1569       if(rrcContainer->buf != NULLP)
1570       {
1571          memset(rrcContainer->buf, 0, bufLen);
1572          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1573       }
1574       else
1575       {
1576          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1577          ret = RFAILED;
1578       }
1579    }
1580    else if(rrcMsgType == RRC_SECURITY_MODE_COMPLETE)
1581    {
1582       /*Hardcoded RRC Container from reference logs*/
1583       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1584       char buf[14] ={0x00, ueCb->pdcpSn++, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1585       bufLen =14;
1586       rrcContainer->size = bufLen;
1587       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1588       if(rrcContainer->buf != NULLP)
1589       {
1590          memset(rrcContainer->buf, 0, bufLen);
1591          memcpy(rrcContainer->buf, buf, bufLen);
1592       }
1593       else
1594       {
1595          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1596          ret = RFAILED;
1597       }
1598    }
1599    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1600    {
1601       uint16_t tmpBufIdx = 0, bufIdx = 0;
1602       RRCContainer_t rrcContainerTmp;
1603       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1604       ret = fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, false);
1605       rrcContainer->size = rrcContainerTmp.size + 2;
1606       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1607       if(rrcContainer->buf != NULLP)
1608       {
1609          memset(rrcContainer->buf, 0, rrcContainer->size);
1610          rrcContainer->buf[0] = 0x00;
1611          rrcContainer->buf[1] = ueCb->pdcpSn++; //PDCP SN
1612          for(bufIdx = 2, tmpBufIdx = 0; bufIdx < rrcContainer->size; bufIdx++, tmpBufIdx++)
1613          {
1614             rrcContainer->buf[bufIdx] = rrcContainerTmp.buf[tmpBufIdx];
1615          }
1616       }
1617       if(ret == RFAILED)
1618          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1619    }
1620
1621    return ret;
1622 }
1623
1624 /*******************************************************************
1625  *
1626  * @brief Frees the DLRRCMessageTransfer
1627  *
1628  * @details
1629  *
1630  *    Function : freeDlRrcMessageTransfer
1631  *
1632  *    Functionality: Frees the DLRRCMessageTransfer
1633  *
1634  * @params[in]
1635  *
1636  * @return ROK     - success
1637  *         RFAILED - failure
1638  *
1639  * ****************************************************************/
1640 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1641 {
1642    uint8_t idx=0;
1643    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1644
1645    if(f1apMsg)
1646    {
1647       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1648       if(dlRRCMsg->protocolIEs.list.array)
1649       {
1650          idx = 3;
1651          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1652             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1653          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1654          {
1655             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1656          }
1657          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1658       }
1659       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1660    }
1661 }
1662
1663 /*******************************************************************
1664  *
1665  * @brief Builds and sends the DLRRCMessageTransfer
1666  *
1667  * @details
1668  *
1669  *    Function : BuildAndSendDLRRCMessageTransfer
1670  *
1671  *    Functionality: Constructs the DL RRC Message Transfer and sends
1672  *                   it to the CU through SCTP.
1673  *
1674  * @params[in]
1675  *
1676  * @return ROK     - success
1677  *         RFAILED - failure
1678  *
1679  * ****************************************************************/
1680 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1681 {
1682    uint8_t   elementCnt = 0;
1683    uint8_t  ieId;
1684    uint8_t  idx;
1685    F1AP_PDU_t  *f1apMsg = NULLP;
1686    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1687    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1688
1689    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1690
1691    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1692    if(f1apMsg == NULLP)
1693    {
1694       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1695       return RFAILED;
1696    }
1697
1698    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1699    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1700    if(f1apMsg->choice.initiatingMessage == NULLP)
1701    {
1702       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1703       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1704       return RFAILED;
1705    }
1706
1707    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1708    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1709    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1710    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1711
1712    elementCnt = 4;
1713    dlRRCMsg->protocolIEs.list.count = elementCnt;
1714    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1715
1716    /* Initialize the F1Setup members */
1717    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1718    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1719    {
1720       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1721       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1722       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1723       return RFAILED;
1724    }
1725
1726    for(idx=0; idx<elementCnt; idx++)
1727    {
1728       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1729       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1730       {
1731          for(ieId=0; ieId<idx; ieId++)
1732          {
1733             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1734          }
1735          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1736          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1737          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1738          return RFAILED;
1739       }
1740    }
1741
1742    /* GNB CU UE F1AP ID */
1743    idx = 0;
1744    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1745    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1746    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1747    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1748
1749    /* GNB DU UE F1AP ID */
1750    idx++;
1751    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1752    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1753    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1754    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1755
1756    /* SRBID */
1757    idx++;
1758    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1759    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1760    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1761    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1762
1763    /* RRCContainer */
1764    idx++;
1765    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1766    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1767    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1768    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1769
1770    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1771
1772    /* Encode the F1SetupRequest type as APER */
1773    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1774    encBufSize = 0;
1775    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1776          encBuf);
1777    /* Encode results */
1778    if(encRetVal.encoded == ENCODE_FAIL)
1779    {
1780       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1781             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1782       return RFAILED;
1783    }
1784    else
1785    {
1786       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1787       for(int i=0; i< encBufSize; i++)
1788       {
1789          DU_LOG("%x",encBuf[i]);
1790       }
1791    }
1792
1793    /* Sending  msg  */
1794    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1795    {
1796       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1797       return RFAILED;
1798    }
1799    freeDlRrcMessageTransfer(f1apMsg);
1800    return ROK;
1801 }/* End of BuildAndSendDLRRCMessageTransfer */
1802
1803 /*******************************************************************
1804  *
1805  * @brief Function to set the Dl RRC Msg Type
1806  *
1807  * @details
1808  *
1809  *    Function : setDlRRCMsgType
1810  *
1811  *    Functionality: Constructs the UE Setup Response and sends
1812  *                   it to the DU through SCTP.
1813  *
1814  * @params[in]
1815  *
1816  * @return ROK     - success
1817  *         RFAILED - failure
1818  *
1819  * ****************************************************************/
1820
1821 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1822 {
1823    uint8_t rrcMsgType = 0;
1824    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1825    {
1826       case RRC_SETUP:
1827          rrcMsgType = RRC_SETUP;
1828          break;
1829       case RRC_SETUP_COMPLETE:
1830          rrcMsgType = RRC_SETUP_COMPLETE;
1831          break;
1832       case NAS_AUTHENTICATION_RSP:
1833          rrcMsgType = NAS_AUTHENTICATION_RSP;
1834          break;
1835       case NAS_SECURITY_MODE_COMPLETE:
1836          rrcMsgType = NAS_SECURITY_MODE_COMPLETE;
1837          break;
1838       case RRC_SECURITY_MODE_COMPLETE:
1839          rrcMsgType = RRC_SECURITY_MODE_COMPLETE;
1840          break;
1841       case REGISTRATION_COMPLETE:
1842          rrcMsgType = REGISTRATION_COMPLETE;
1843          break;
1844       case UE_CONTEXT_SETUP_RSP:
1845          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1846          break;
1847       case RRC_RECONFIG_COMPLETE:
1848          rrcMsgType = RRC_RECONFIG_COMPLETE;
1849          break;
1850       default:
1851          break;
1852    }
1853    return rrcMsgType;
1854 }
1855
1856 #ifdef NR_DRX
1857 /*******************************************************************
1858  *
1859  * @brief fill long cycle offset value of drx
1860  *
1861  * @details
1862  *
1863  *    Function : fillLongCycleOffsetValue
1864  *
1865  *    Functionality: fill long cycle offset value of drx
1866  *
1867  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
1868  * struct DRX_ConfigRrc__drx_LongCycleStartOffset recvedLongCycleOffsetVal
1869  *
1870  * @return ROK     - success
1871  *         RFAILED - failure
1872  *
1873  * ****************************************************************/
1874 void fillLongCycleOffsetValue(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset *recvedLongCycleOffsetVal)
1875 {
1876
1877    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = recvedLongCycleOffsetVal->present;
1878    switch(recvedLongCycleOffsetVal->present)
1879    {
1880       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
1881          {
1882             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10;
1883             break;
1884          }
1885       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
1886          {
1887             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms20;
1888             break;
1889          }
1890       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
1891          {
1892             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms32;
1893             break;
1894          }
1895       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
1896          {
1897             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms40;
1898             break;
1899          }
1900       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
1901          {
1902             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms60;
1903             break;
1904          }
1905       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
1906          {
1907             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms64;
1908             break;
1909          }
1910       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
1911          {
1912             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms70;
1913             break;
1914          }
1915       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
1916          {
1917             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms80;
1918             break;
1919          }
1920       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
1921          {
1922             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms128;
1923             break;
1924          }
1925       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
1926          {
1927             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms160;
1928             break;
1929          }
1930       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
1931          {
1932             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms256;
1933             break;
1934          }
1935       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
1936          {
1937             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms320;
1938             break;
1939          }
1940       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
1941          {
1942             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms512;
1943             break;
1944          }
1945       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
1946          {
1947             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms640;
1948             break;
1949          }
1950       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
1951          {
1952             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1024;
1953             break;
1954          }
1955       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
1956          {
1957             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1280;
1958             break;
1959          }
1960       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
1961          {
1962             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2048;
1963             break;
1964          }
1965       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
1966          {
1967             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2560;
1968             break;
1969          }
1970       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
1971          {
1972             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms5120;
1973             break;
1974          }
1975       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
1976          {
1977             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10240;
1978             break;
1979          }
1980       default :
1981          break;
1982    }
1983 }
1984
1985 /*******************************************************************
1986  *
1987  * @brief Extract configuration from DRX_ConfigRrc
1988  *    and store the drx configuration in UeCb
1989  *
1990  * @details
1991  *
1992  *    Function : storeDrxCfgInUeCb
1993  *
1994  *    Functionality: Store drx configuration in UeCb
1995  *
1996  * @params[in] (struct DRX_ConfigRrc *setup, DrxCfg *drxCfg)
1997  *
1998  * @return void
1999  * ****************************************************************/
2000 void storeDrxCfgInUeCb(struct DRX_ConfigRrc *drxSetup, DrxCfg *drxCfg)
2001 {
2002    switch(drxSetup->drx_onDurationTimer.present)
2003    {
2004       case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
2005          break;
2006       case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
2007          {
2008             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
2009             drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=drxSetup->drx_onDurationTimer.choice.milliSeconds;
2010             break;
2011          }
2012       case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
2013          {
2014             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
2015             drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = drxSetup->drx_onDurationTimer.choice.subMilliSeconds;
2016             break;
2017          }
2018    }
2019    fillLongCycleOffsetValue(&drxCfg->drxLongCycleStartOffset, &drxSetup->drx_LongCycleStartOffset);
2020    drxCfg->drxInactivityTimer = drxSetup->drx_InactivityTimer;
2021    drxCfg->drxHarqRttTimerDl = drxSetup->drx_HARQ_RTT_TimerDL;
2022    drxCfg->drxHarqRttTimerUl = drxSetup->drx_HARQ_RTT_TimerUL;
2023    drxCfg->drxRetransmissionTimerDl = drxSetup->drx_RetransmissionTimerDL;
2024    drxCfg->drxRetransmissionTimerUl = drxSetup->drx_RetransmissionTimerUL;
2025    drxCfg->drxSlotOffset = drxSetup->drx_SlotOffset;
2026    if(drxSetup->shortDRX)
2027    {
2028       drxCfg->shortDrxPres=true;
2029       drxCfg->shortDrx.drxShortCycle = drxSetup->shortDRX->drx_ShortCycle;
2030       drxCfg->shortDrx.drxShortCycleTimer = drxSetup->shortDRX->drx_ShortCycleTimer;
2031    }
2032    else
2033       drxCfg->shortDrxPres=false;
2034 }
2035 #endif
2036
2037 /*******************************************************************
2038  *
2039  * @brief Extract configuration from CellGroupConfig
2040  *
2041  * @details
2042  *
2043  *    Function : extractCellGroupConfig
2044  *
2045  *    Functionality: Extract configuration from CellGroupConfig
2046  *        and store in local database
2047  *
2048  * @params[in] UE control block
2049  *             Cell Group Config
2050  *
2051  * @return ROK     - success
2052  *         RFAILED - failure
2053  *
2054  * ****************************************************************/
2055 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
2056 {
2057    uint8_t rbIdx, srbIdx, drbIdx;
2058    bool    srbFound, drbFound;
2059    SrbInfo *srbCfgDb = NULLP;
2060    DrbInfo *drbCfgDb = NULLP;
2061    RlcLcCfg *rlcLcCfgDb = NULLP;
2062    MacLcCfg *macLcCfgDb = NULLP;
2063    RLC_BearerConfig_t *rlcCfg = NULLP;
2064    RLC_Config_t *rlcLcCfg = NULLP;
2065    LogicalChannelConfig_t *macLcCfg = NULLP;
2066 #ifdef NR_DRX
2067    DrxCfg    drxCfg;
2068 #endif
2069
2070    if(ueCb == NULLP)
2071    {
2072       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
2073       return RFAILED;
2074    }
2075
2076    if(cellGrpCfg == NULLP)
2077    {
2078       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
2079       return RFAILED;
2080    }
2081
2082 #ifdef NR_DRX
2083    if(cellGrpCfg->mac_CellGroupConfig)
2084    {
2085       if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc)
2086       {
2087          switch(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->present)
2088          {
2089             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
2090                break;
2091
2092             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
2093             {
2094                if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup)
2095                {
2096                   ueCb->drxCfgPresent = true;
2097                   storeDrxCfgInUeCb(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup, &ueCb->drxCfg);
2098                }
2099                break;
2100             }
2101
2102             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
2103                break;
2104          }
2105       }
2106    }
2107 #endif
2108
2109    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
2110    {
2111       srbFound = false;
2112       drbFound = false;
2113
2114       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
2115
2116       /* Update SRB configuration in local DB */
2117       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
2118       {
2119          /* Search if SRB entry is already present in DB */
2120          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
2121          {
2122             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
2123             {
2124               srbCfgDb = &ueCb->srbList[srbIdx];
2125               srbFound = true;
2126               break;
2127             }
2128          }
2129
2130          /* If not, add SRB to UE CB's SRB list */
2131          if(!srbFound)
2132          {
2133             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
2134             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
2135             ueCb->numSrb++;
2136          }
2137
2138          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2139          srbCfgDb->cfgSentToUe = false;
2140          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
2141          macLcCfgDb = &srbCfgDb->macLcCfg;
2142       }
2143
2144       /* Update DRB configuration in local DB */
2145       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
2146       {
2147          /* Search if DRB entry is already present in DB */
2148          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
2149          {
2150             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
2151             {
2152               drbCfgDb = &ueCb->drbList[drbIdx];
2153               drbFound = true;
2154               break;
2155             }
2156          }
2157
2158          /* If not, add DRB to UE CB's SRB list */
2159          if(!drbFound)
2160          {
2161             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
2162             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
2163             ueCb->numDrb++;
2164          }
2165
2166          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2167          drbCfgDb->cfgSentToUe = false;
2168          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
2169          macLcCfgDb = &drbCfgDb->macLcCfg;
2170       }
2171
2172
2173       /* Update RLC configuration for this RB */
2174       rlcLcCfg = rlcCfg->rlc_Config;
2175       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
2176       switch(rlcLcCfgDb->rlcMode)
2177       {
2178          case RLC_Config_PR_am:
2179             {
2180                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
2181                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
2182                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
2183                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
2184                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
2185
2186                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
2187                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
2188                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
2189                break;
2190             }
2191
2192          case RLC_Config_PR_um_Bi_Directional:
2193             {
2194                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
2195
2196                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
2197                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
2198                break;
2199             }
2200       }
2201
2202       /* Update MAC configuration for this LC */
2203       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
2204       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
2205       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
2206       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
2207       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
2208       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
2209    }
2210    return ROK;
2211 }
2212
2213 /*******************************************************************
2214  *
2215  * @brief Function to decode DU to CU RRC container
2216  *
2217  * @details
2218  *
2219  *    Function : extractDuToCuRrcCont
2220  *
2221  *    Functionality: Function to decode DU to CU RRC container
2222  *
2223  * @params[in] UE Cb
2224  *             RRC conatiner octect string to be decoded
2225  *
2226  * @return ROK     - success
2227  *         RFAILED - failure
2228  *
2229  * ****************************************************************/
2230 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
2231 {
2232    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
2233    asn_dec_rval_t rval; /* Decoder return value */
2234
2235    /* Copy the received container to UeCb */
2236    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
2237
2238    /* Decoding DU to CU RRC container octet string to cell group config */
2239    cellGrpCfgMsg = &cellGrpCfg;
2240    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
2241
2242    rval = uper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
2243
2244    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2245    {
2246       DU_LOG("\nERROR  -->  F1AP : ASN decode failed in extractDuToCuRrcCont");
2247       return RFAILED;
2248    }
2249    printf("\n");
2250    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
2251
2252    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
2253    {
2254       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
2255       return RFAILED;
2256    }
2257
2258    return ROK;
2259 }
2260
2261 /*******************************************************************
2262  *
2263  * @brief Function to build Initial UL RRC Message
2264  *
2265  * @details
2266  *
2267  *    Function : procInitULRRCMsg
2268  *
2269  *    Functionality: Function to build Initial UL RRC Message
2270  *
2271  * @params[in]
2272  *
2273  * @return ROK     - success
2274  *         RFAILED - failure
2275  *
2276  * ****************************************************************/
2277
2278 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2279 {
2280    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2281    uint8_t ret =ROK;
2282    uint16_t cellIdx=0, nrCellId = 0;
2283    uint32_t crnti;
2284    DuDb     *duDb;
2285    CuCellCb *cellCb;
2286    CuUeCb   *ueCb;
2287    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2288
2289    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2290
2291    SEARCH_DU_DB(duIdx, duId, duDb);
2292    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2293
2294    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2295    {
2296       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2297       {
2298          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2299             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2300             break;
2301
2302          case ProtocolIE_ID_id_NRCGI:
2303             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2304             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2305             if(cellCb == NULLP)
2306                return RFAILED;
2307             break;
2308
2309          case ProtocolIE_ID_id_C_RNTI:
2310             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2311             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2312             {
2313                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2314                memset(ueCb, 0, sizeof(CuUeCb));
2315                ueCb->cellCb = cellCb;
2316                ueCb->crnti = crnti;
2317                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2318                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2319                ueCb->state = UE_ATTACH_IN_PROGRESS;
2320                (duDb->numUe)++;
2321
2322                cellCb->ueCb[cellCb->numUe] = ueCb;
2323                cellCb->numUe++;
2324             }
2325             break;
2326
2327          case ProtocolIE_ID_id_RRCContainer:
2328             break;
2329
2330          case ProtocolIE_ID_id_DUtoCURRCContainer:
2331             {
2332                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2333                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2334                {
2335                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2336                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2337                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2338                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2339                   {
2340                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2341                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2342                         ueCb->f1apMsgDb.duToCuContainer.size);
2343                   }
2344                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2345                   {
2346                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2347                      ret = RFAILED;
2348                   }
2349                }
2350                else
2351                {
2352                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2353                   ret = RFAILED;
2354                }
2355                break;
2356             }
2357
2358          default:
2359             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2360             break;
2361       }
2362       if(ret == RFAILED)
2363          break;
2364    }
2365
2366    if(ret == ROK)
2367    {
2368       ueCb->f1apMsgDb.dlRrcMsgCount++;
2369       rrcMsgType = setDlRRCMsgType(ueCb);
2370       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2371    }
2372    return ret;
2373 }
2374
2375 /*******************************************************************
2376  *
2377  * @brief Builds Nrcgi
2378  *
2379  * @details
2380  *
2381  *    Function : BuildNrcgi
2382  *
2383  *    Functionality: Building the PLMN ID and NR Cell id
2384  *
2385  * @params[in] NRCGI_t *nrcgi
2386  * @return ROK     - success
2387  *         RFAILED - failure
2388  *
2389  * ****************************************************************/
2390 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2391 {
2392    uint8_t ret;
2393    uint8_t unused_bits = 4;
2394    uint8_t byteSize = 5;
2395
2396    /* Allocate Buffer Memory */
2397    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2398    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2399    if(nrcgi->pLMN_Identity.buf == NULLP)
2400    {
2401       return RFAILED;
2402    }
2403    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2404
2405    if(ret != ROK)
2406    {
2407       return RFAILED;
2408    }
2409    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2410    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2411    if(nrcgi->nRCellIdentity.buf == NULLP)
2412    {
2413       return RFAILED;
2414    }
2415    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2416
2417    return ROK;
2418 }
2419 /*******************************************************************
2420  *
2421  * @brief Builds Special cell list for UE Setup Request
2422  *
2423  * @details
2424  *
2425  *    Function : BuildSplCellList
2426  *
2427  *    Functionality: Constructs the Special Cell list for UESetReq
2428  *
2429  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2430  *
2431  * @return ROK     - success
2432  *         RFAILED - failure
2433  *
2434  * ****************************************************************/
2435 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2436 {
2437    uint8_t  cellCnt;
2438    uint8_t  idx;
2439    uint8_t  ret;
2440    cellCnt = 1;
2441    spCellLst->list.count = cellCnt;
2442    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2443    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2444    if(spCellLst->list.array == NULLP)
2445    {
2446       return RFAILED;
2447    }
2448    for(idx=0; idx<cellCnt; idx++)
2449    {
2450       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2451       if(spCellLst->list.array[idx] == NULLP)
2452       {
2453          return RFAILED;
2454       }
2455    }
2456    idx = 0;
2457    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2458    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2459    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2460
2461    /* Special Cell ID -NRCGI */
2462    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2463    if(ret != ROK)
2464    {
2465       return RFAILED;
2466    }
2467    /*Special Cell Index*/
2468    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2469    return ROK;
2470 }/* End of BuildSplCellList*/
2471
2472 /*******************************************************************
2473  *
2474  * @brief Builds SRBS to be setup
2475  *
2476  * @details
2477  *
2478  *    Function : BuildSRBSetup
2479  *
2480  *    Functionality: Constructs the SRB's for UESetReq
2481  *
2482  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2483  *
2484  * @return ROK     - success
2485  *         RFAILED - failure
2486  *
2487  * ****************************************************************/
2488 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2489 {
2490    uint8_t idx;
2491    uint8_t srbCnt;
2492
2493    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2494       srbCnt = ueCb->numSrb;
2495    else
2496       srbCnt = 1;
2497    srbSet->list.count = srbCnt;
2498    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2499    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2500    if(srbSet->list.array == NULLP)
2501    {
2502       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2503       return RFAILED;
2504    }
2505
2506    for(idx=0; idx<srbCnt; idx++)
2507    {
2508       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2509       if(srbSet->list.array[idx] == NULLP)
2510       {
2511          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2512          return RFAILED;
2513       }
2514    }
2515
2516    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2517    {
2518       idx = 0;
2519       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2520       srbSet->list.array[idx]->criticality = Criticality_ignore;
2521       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2522       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2523       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2524       ueCb->numSrb++;
2525    }
2526    else
2527    {
2528       for(idx=0; idx<srbCnt; idx++)
2529       {
2530          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2531          srbSet->list.array[idx]->criticality = Criticality_ignore;
2532          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2533          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2534       }
2535    }
2536    return ROK;
2537 }/* End of BuildSRBSetup*/
2538
2539 /*******************************************************************
2540  *
2541  * @brief Builds QOS Info for DRB Setum Item
2542  *
2543  * @details
2544  *
2545  *    Function : BuildQOSInfo
2546  *
2547  *    Functionality: Constructs the QOS Info for DRB Setup Item
2548  *
2549  * @params[in] QoSInformation_t *qosinfo
2550  *             int16_t pduSessionID
2551  *
2552  * @return ROK     - success
2553  *         RFAILED - failure
2554  *
2555  * ****************************************************************/
2556 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2557 {
2558    uint8_t elementCnt = 0, qosCntIdx = 0;
2559    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2560
2561    /* NonDynamic5QIDescriptor */
2562    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2563    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2564    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2565    {
2566       return RFAILED;
2567    }
2568
2569    if(hoInProgress)
2570       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2571    else
2572    {
2573       /*FiveQI*/
2574       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2575          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2576       else
2577          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2578
2579       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2580    }
2581
2582    if(!hoInProgress)
2583    {
2584       /*AveragingWindow*/
2585       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2586       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2587       {
2588          return RFAILED;
2589       }
2590       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2591       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2592
2593       /*MaxDataBurstVolume*/
2594       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2595       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2596       {
2597          return RFAILED;
2598       }
2599       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2600       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2601    }
2602
2603    /*nRGRAN Allocation Retention Priority*/
2604    if(hoInProgress)
2605    {
2606       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2607       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2608       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2609    }
2610    else
2611    {
2612       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2613       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2614       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2615
2616       qosInfo->priorityLevel = PriorityLevel_lowest;
2617       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2618       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2619    }
2620
2621    /* PDU session ID */
2622    if(!hoInProgress)
2623    {
2624       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2625       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2626       {
2627          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2628          return ROK;
2629       }
2630
2631       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2632       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2633
2634       if(qosIeExt)
2635       {
2636          elementCnt = NUM_QOS_EXT;
2637          qosIeExt->list.count = elementCnt;
2638          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2639
2640          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2641          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2642
2643          if(qosIeExt->list.array == NULLP)
2644          {
2645             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2646             return  RFAILED;
2647          }
2648
2649          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2650          {
2651             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2652             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2653             {
2654                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2655                return  RFAILED;
2656             }
2657             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2658             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2659             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2660             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2661             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2662                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2663             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2664             qosInfo->pduSessionId = pduSessionID;
2665          }
2666       }
2667       else
2668       {
2669          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2670          return RFAILED;
2671       }
2672    }
2673    return ROK;
2674 }/*End of BuildQOSInfo*/
2675
2676 /*******************************************************************
2677  *
2678  * @brief Builds SNSSAI
2679  *
2680  * @details
2681  *
2682  *    Function : BuildSNSSAI
2683  *
2684  *    Functionality: Constructs the SNSSAI For DRB list
2685  *
2686  * @params[in] SNSSAI_t *snssai
2687  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2688  *
2689  * @return ROK     - success
2690  *         RFAILED - failure
2691  *
2692  * ****************************************************************/
2693 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2694 {
2695    /*SNSSAI*/
2696    /*ssT*/
2697    snssai->sST.size = sizeof(uint8_t);
2698    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2699    if(snssai->sST.buf == NULLP)
2700    {
2701       return RFAILED;
2702    }
2703    if(!hoInProgress)
2704       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2705    else
2706       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2707
2708    /*sD*/
2709    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2710    if(snssai->sD == NULLP)
2711    {
2712       return RFAILED;
2713    }
2714    snssai->sD->size = 3 * sizeof(uint8_t);
2715    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2716    if(snssai->sD->buf == NULLP)
2717    {
2718       return RFAILED;
2719    }
2720    if(!hoInProgress)
2721       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2722    else
2723       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2724
2725    if(!hoInProgress)
2726       drbInfo->snssai = snssaiToCopy;
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    if(!hoInProgress)
2752       flowCnt = 1;
2753    else
2754       flowCnt = drbInfo->numFlowMap;
2755    flowMap->list.count = flowCnt;
2756    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2757    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2758    if(flowMap->list.array == NULLP)
2759    {
2760       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2761       return RFAILED;
2762    }
2763    for(idx=0; idx<flowCnt; idx++)
2764    {
2765       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2766       if(flowMap->list.array[idx] == NULLP)
2767       {
2768          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2769          return RFAILED;
2770       }
2771
2772       if(!hoInProgress)
2773       {
2774          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2775          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2776          {
2777             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2778             {
2779                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2780                {
2781                   qosFlow = &drbInfo->flowMapList[flowIdx];
2782                   break;
2783                }
2784             }
2785          }
2786          else
2787          {
2788             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2789             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2790          }
2791       }
2792       else
2793       {
2794          qosFlow = &drbInfo->flowMapList[idx];
2795          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2796       }
2797
2798       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2799             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2800       if(ret != ROK)
2801       {
2802          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2803          return RFAILED;
2804       }
2805
2806       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2807          drbInfo->numFlowMap++;
2808    }
2809    return ROK;
2810 }/*End of BuildFlowsMap*/
2811
2812 /*******************************************************************
2813  *
2814  * @brief Builds the Uplink Tunnel Info
2815  *
2816  * @details
2817  *
2818  *    Function : BuildULTnlInfo
2819  *
2820  *    Functionality: Constructs the UL TnlInfo For DRB list
2821  *
2822  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2823  *
2824  * @return ROK     - success
2825  *         RFAILED - failure
2826  *
2827  * ****************************************************************/
2828 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2829 {
2830    uint8_t idx;
2831    uint8_t ulCnt;
2832
2833    ulCnt = 1;
2834    ulInfo->list.count = ulCnt;
2835    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2836    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2837    if(ulInfo->list.array == NULLP)
2838    {
2839       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2840       return RFAILED;
2841    }
2842    for(idx=0; idx<ulCnt; idx++)
2843    {
2844       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2845       if(ulInfo->list.array[idx] == NULLP)
2846       {
2847          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2848               return RFAILED;
2849       }
2850    }
2851    idx = 0;
2852    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2853    /*GTP TUNNEL*/
2854    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2855    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2856    {
2857       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2858       return RFAILED;
2859    }
2860    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2861    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2862       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2863    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2864    {
2865       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2866       return RFAILED;
2867    }
2868
2869    if(!hoInProgress)
2870    {
2871       /* NOTE: Below IP address must be changed if running on different IP configuration */
2872       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2873       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2874       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2875       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2876       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2877
2878       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2879       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2880       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2881       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2882    }
2883    else
2884    {
2885       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2886       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2887       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2888       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2889       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2890    }
2891
2892    /*GTP TEID*/
2893    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2894    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2895       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2896    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2897    {
2898       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2899       return RFAILED;
2900    }
2901
2902    if(!hoInProgress)
2903    {
2904       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2905       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2906       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2907       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2908
2909       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2910       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2911       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2912       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2913    }
2914    else
2915    {
2916       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2917       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2918       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2919       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2920    }
2921    return ROK;
2922 }/*End of BuildULTnlInfo*/
2923
2924 /*******************************************************************
2925  *
2926  * @brief Builds DRBS to be setup
2927  *
2928  * @details
2929  *
2930  *    Function : BuildDRBSetup
2931  *
2932  *    Functionality: Constructs the DRB's for UESetReq
2933  *
2934  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2935  *
2936  * @return ROK     - success
2937  *         RFAILED - failure
2938  *
2939  * ****************************************************************/
2940 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2941 {
2942    uint16_t snssaiIdx=0;
2943    uint8_t idx = 0, extIeIdx = 0;
2944    uint8_t elementCnt = 0, drbCnt = 0;
2945    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2946    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2947    DRBs_ToBeSetup_Item_t *drbSetItem;
2948    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2949    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2950
2951    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2952       drbCnt = ueCb->numDrb;
2953    else
2954       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2955    drbSet->list.count = drbCnt;
2956
2957    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2958    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2959    if(drbSet->list.array == NULLP)
2960    {
2961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2962       return RFAILED;
2963    }
2964
2965    for(idx=0; idx<drbCnt; idx++)
2966    {
2967       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2968       if(drbSet->list.array[idx] == NULLP)
2969       {
2970          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2971          return RFAILED;
2972       }
2973
2974       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2975       drbSet->list.array[idx]->criticality = Criticality_ignore;
2976       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2977       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2978       /*dRBID*/
2979       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2980       {
2981          drbSetItem->dRBID = idx + 1;
2982          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2983       }
2984       else
2985          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2986
2987       /*qoSInformation*/
2988       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2989       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2990       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2991       {
2992          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2993          return RFAILED;
2994       }
2995       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2996       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2997       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2998       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2999          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
3000                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
3001       else
3002          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
3003                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
3004       if(BuildQOSInforet != ROK)
3005       {
3006          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
3007          return RFAILED;
3008       }
3009
3010       /*SNSSAI*/
3011       snssaiIdx = (idx% cuCb.numSnssaiSupported);
3012       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3013          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
3014                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
3015       else
3016          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
3017                choice_extension->value.choice.DRB_Information.sNSSAI, NULLP, TRUE);
3018       if(BuildSNSSAIret != ROK)
3019       {
3020          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
3021          return RFAILED;
3022       }
3023
3024       /*Flows mapped to DRB List*/
3025       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3026          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
3027                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
3028       else
3029          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
3030                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
3031       if(BuildFlowsMapret != ROK)
3032       {
3033          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
3034          return RFAILED;
3035       }
3036
3037       /*ULUPTNLInformation To Be Setup List*/
3038       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3039          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3040                FALSE);
3041       else
3042          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3043                TRUE);
3044       if(BuildULTnlInforet != ROK)
3045       {
3046          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
3047          return RFAILED;
3048       }
3049
3050       /*RLCMode*/
3051       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3052       {
3053          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
3054          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
3055       }
3056       else
3057          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
3058
3059       /* DL PDCP SN Length */
3060       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
3061       {
3062          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
3063          if(!drbToBeSetupExt)
3064          {
3065             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
3066             return RFAILED;
3067          }
3068
3069          elementCnt = 1;
3070          drbToBeSetupExt->list.count = elementCnt;
3071          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
3072
3073          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
3074          if(!drbToBeSetupExt->list.array)
3075          {
3076              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
3077              return RFAILED;
3078          }
3079
3080          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
3081          {
3082             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
3083             if(!drbToBeSetupExt->list.array[extIeIdx])
3084             {
3085                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
3086                return RFAILED;
3087             }
3088          }
3089
3090          extIeIdx = 0;
3091          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
3092
3093          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
3094          drbToBeSetupExtIe->criticality = Criticality_ignore;
3095          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
3096          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
3097          drbSetItem->iE_Extensions = drbToBeSetupExt;
3098       }
3099
3100       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3101          ueCb->numDrb++;
3102    }
3103    return ROK;
3104 }/* End of BuildDRBSetup*/
3105
3106 /*******************************************************************
3107  *
3108  * @brief Deallocating memory of function BuildAndSendUESetReq
3109  *
3110  * @details
3111  *
3112  *    Function : FreeNrcgi
3113  *
3114  *    Functionality: Deallocating memory for function BuildNrcgi
3115  *
3116  * @params[in] NRCGI_t *nrcgi
3117  *
3118  * @return void
3119  *
3120  *******************************************************************/
3121 void FreeNrcgi(NRCGI_t *nrcgi)
3122 {
3123    if(nrcgi->pLMN_Identity.buf != NULLP)
3124    {
3125       if(nrcgi->nRCellIdentity.buf != NULLP)
3126       {
3127          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
3128       }
3129       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
3130    }
3131 }
3132 /*******************************************************************
3133  *
3134  * @brief  Deallocating memory of function BuildAndSendUESetReq
3135  *
3136  * @details
3137  *
3138  *    Function : FreeSplCellList
3139  *
3140  *    Functionality: Deallocating memory for function BuildSplCellList
3141  *
3142  * @params[in] SCell_ToBeSetup_List_t *spCellLst
3143  *
3144  * @return void
3145  *
3146  *
3147  * *****************************************************************/
3148 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
3149 {
3150    uint8_t  cellidx;
3151    if(spCellLst->list.array != NULLP)
3152    {
3153       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
3154       {
3155          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
3156          {
3157             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
3158          }
3159          if(spCellLst->list.array[cellidx]!=NULLP)
3160          {
3161             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
3162          }
3163       }
3164       CU_FREE(spCellLst->list.array,spCellLst->list.size);
3165    }
3166 }
3167 /*******************************************************************
3168  *
3169  * @brief Deallocating memory of function BuildAndSendUESetReq
3170  *
3171  * @details
3172  *
3173  *    Function : FreeSRBSetup
3174  *
3175  *    Functionality: Deallocating memory for function BuildSRBSetup
3176  *
3177  * @params[in] SRBs_ToBeSetup_List_t *srbSet
3178  *
3179  * @return void
3180  *
3181  *
3182  * ******************************************************************/
3183 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
3184 {
3185    uint8_t srbidx;
3186    if(srbSet->list.array != NULLP)
3187    {
3188       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
3189       {
3190          if(srbSet->list.array[srbidx]!=NULLP)
3191          {
3192             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
3193          }
3194       }
3195       CU_FREE(srbSet->list.array,srbSet->list.size);
3196    }
3197 }
3198 /*******************************************************************
3199  *
3200  * @brief Deallocating memory of function BuildAndSendUESetReq
3201  *
3202  * @details
3203  *
3204  *    Function : FreeQOSInfo
3205  *
3206  *    Functionality:  Deallocating memory for function BuildQOSInfo
3207  *
3208  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
3209  *
3210  * @return void
3211  *
3212  * ****************************************************************/
3213 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
3214 {
3215    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3216    uint8_t qosCntIdx = 0;
3217
3218    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
3219    {
3220       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3221       {
3222          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3223          {
3224             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3225                   sizeof(MaxDataBurstVolume_t));
3226          }
3227          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3228                sizeof(AveragingWindow_t));
3229       }
3230       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3231             sizeof(NonDynamic5QIDescriptor_t));
3232    }
3233    if(drbQos->iE_Extensions)
3234    {
3235       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
3236       if(qosIeExt->list.array != NULLP)
3237       {
3238          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
3239          {
3240             if(qosIeExt->list.array[qosCntIdx])
3241             {
3242                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3243             }
3244          }
3245          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3246       }
3247
3248       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3249    }
3250 }
3251 /*******************************************************************
3252  *
3253  * @brief Deallocating memory of function BuildAndSendUESetReq
3254  *
3255  * @details
3256  *
3257  *    Function : FreeULTnlInfo
3258  *
3259  *    Functionality:  Deallocating memory for function BuildULTnlInfo
3260  *
3261  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
3262  *
3263  * @return void
3264  *
3265
3266  * ****************************************************************/
3267 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
3268 {
3269    uint8_t ulidx=0;
3270    if(ulInfo->list.array != NULLP)
3271    {
3272       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
3273       {
3274          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3275          {
3276             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3277             {
3278                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3279                      transportLayerAddress.buf != NULLP)
3280                {
3281                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3282                         !=NULLP)
3283                   {
3284                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3285                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3286                            gTPTunnel->gTP_TEID.size);
3287                   }
3288                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3289                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3290                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3291                }
3292                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3293                      sizeof(GTPTunnel_t));
3294             }
3295          }
3296          if(ulInfo->list.array[ulidx]!=NULLP)
3297          {
3298             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3299          }
3300       }
3301       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3302    }
3303 }
3304 /*******************************************************************
3305  *
3306  * @brief Deallocating memory for BuildAndSendUESetReq
3307  *
3308  * @details
3309  *
3310  *    Function : FreeDRBSetup
3311  *
3312  *    Functionality:  Deallocating memory for BuildDRBSetup
3313  *
3314  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3315  *
3316  * @return void
3317  *
3318  * ****************************************************************/
3319 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3320 {
3321    DRBs_ToBeSetup_Item_t *drbSetItem;
3322    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3323
3324    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3325
3326    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3327    if(drbSet->list.array != NULLP)
3328    {
3329       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3330       {
3331               if(drbSet->list.array[drbidx] != NULLP)
3332               {
3333                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3334                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3335                  {
3336                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3337                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3338                {
3339                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3340                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3341                             {
3342                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3343                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3344                                {
3345                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3346                                        {
3347                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3348                                           {
3349                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3350                                              {
3351                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3352                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3353                                                      {
3354                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3355                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3356                                                          {
3357                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3358                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3359                                                              {
3360                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3361                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3362                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=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->averagingWindow!=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->maxDataBurstVolume!=NULLP)
3371                                                                                   {
3372                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3373                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3374
3375                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3376                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3377                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3378                                                                                                    sizeof(MaxDataBurstVolume_t));
3379                                                                                   }
3380                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3381                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3382                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_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,sizeof(NonDynamic5QIDescriptor_t));
3387                                                                      }
3388                                                             }
3389                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3390                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3391                                                             {
3392                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3393                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3394                                                             }
3395                                                         }
3396                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3397                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3398                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3399                                                      }
3400                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3401                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3402                                             }
3403                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3404                                                               sizeof(OCTET_STRING_t));
3405                                        }
3406                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3407                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3408                                     }
3409                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3410                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3411                             }
3412                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3413                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3414                          }
3415                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3416                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3417              }
3418              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3419                         iE_Extensions != NULLP)
3420              {
3421                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3422                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3423                  if(qosIeExt->list.array != NULLP)
3424                  {
3425                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3426                    {
3427                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3428                       {
3429                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3430                       }
3431                     }
3432                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3433                   }
3434                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3435                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3436               }
3437
3438                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3439                 }
3440                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3441               }
3442       }
3443       CU_FREE(drbSet->list.array,drbSet->list.size);
3444    }
3445 }
3446
3447
3448 /*******************************************************************
3449  *
3450  * @brief Free the UE Setup Request
3451  *
3452  * @details
3453  *
3454  *    Function : FreeUeContextSetupReq
3455  *
3456  *    Functionality: Deallocate the memory of BuildUESetReq
3457  *
3458  * @params[in]  F1AP_PDU_t  *f1apMsg
3459  *
3460  * @return void
3461  *
3462  *
3463  * ****************************************************************/
3464 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3465 {
3466    uint8_t idx, ieId;
3467    UEContextSetupRequest_t  *ueSetReq = NULLP;
3468
3469    if(f1apMsg != NULLP)
3470    {
3471       if(f1apMsg->choice.initiatingMessage != NULLP)
3472       {
3473          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3474          if(ueSetReq->protocolIEs.list.array != NULLP)
3475          {
3476             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3477             {
3478                if(ueSetReq->protocolIEs.list.array[idx])
3479                {
3480                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3481                   {
3482                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3483                         break;
3484                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3485                         break;
3486                      case ProtocolIE_ID_id_SpCell_ID:
3487                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3488                         break;
3489                      case ProtocolIE_ID_id_ServCellIndex:
3490                         break;
3491                      case ProtocolIE_ID_id_SpCellULConfigured:
3492                         break;
3493                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3494                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3495                         break;
3496                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3497                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3498                         break;
3499                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3500                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3501                         break;
3502                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3503                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3504                         break;
3505                      case ProtocolIE_ID_id_RRCContainer:
3506                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3507                         {
3508                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3509                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3510                         }
3511                         break;
3512                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3513                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3514                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3515                         break;
3516                      default:
3517                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3518                         break;
3519                   }
3520                }
3521                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3522             }
3523             for(ieId=0; ieId<idx; ieId++)
3524             {
3525                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3526                {
3527                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3528                }
3529             }
3530             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3531          }
3532          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3533       }
3534       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3535    }
3536 }
3537
3538 /**Filling cell group info **/
3539 /*******************************************************************
3540  *
3541  * @brief Build Control resource set to add/modify list
3542  *
3543  * @details
3544  *
3545  *    Function : BuildControlRSetToAddModList
3546  *
3547  *    Functionality: Build Control resource set to add/modify list
3548  *
3549  * @params[in]
3550  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3551  *
3552  * @return ROK     - success
3553  *         RFAILED - failure
3554  *
3555  * ****************************************************************/
3556    uint8_t BuildControlRSetToAddModList
3557 (
3558  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3559  )
3560 {
3561    uint8_t idx;
3562    uint8_t elementCnt;
3563    uint8_t numBytes, bitsUnused;
3564    struct ControlResourceSet *controlRSet;
3565    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3566    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3567
3568    elementCnt = 1;
3569    controlRSetList->list.count = elementCnt;
3570    controlRSetList->list.size = \
3571                                 elementCnt * sizeof(struct ControlResourceSet *);
3572
3573    controlRSetList->list.array = NULLP;
3574    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3575    if(!controlRSetList->list.array)
3576    {
3577       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3578       return RFAILED;
3579    }
3580
3581    for(idx = 0; idx < elementCnt; idx++)
3582    {
3583       controlRSetList->list.array[idx] = NULLP;
3584       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3585       if(!controlRSetList->list.array[idx])
3586       {
3587          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3588          return RFAILED;
3589       }
3590    }
3591
3592    idx=0;
3593    controlRSet = controlRSetList->list.array[idx];
3594    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3595
3596    /* Values harcoded according to our design:
3597     * size 6 bytes
3598     * 3 LSBs unsued
3599     * Bit string stored ff0000000000
3600     */
3601    numBytes = 6;
3602    bitsUnused = 3;
3603    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3604    controlRSet->frequencyDomainResources.buf = NULLP;
3605    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3606          controlRSet->frequencyDomainResources.size);
3607    if(!controlRSet->frequencyDomainResources.buf)
3608    {
3609       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3610       return RFAILED;
3611    }
3612
3613    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3614    coreset0EndPrb = CORESET0_END_PRB;
3615    coreset1StartPrb = coreset0EndPrb + 6;
3616    coreset1NumPrb = CORESET1_NUM_PRB;
3617    /* calculate the PRBs */
3618    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3619    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3620    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3621
3622    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3623    controlRSet->cce_REG_MappingType.present = \
3624                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3625
3626    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3627    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3628    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3629    controlRSet->tci_PresentInDCI = NULLP;
3630 #if 0
3631    uint8_t tciStateIdx;
3632
3633    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3634          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3635    if(!controlRset->tci_StatesPDCCH_ToAddList)
3636    {
3637       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3638       return RFAILED;
3639    }
3640
3641    elementCnt = 1;
3642    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3643    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3644    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3645          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3646       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3647       {
3648          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3649          return RFAILED;
3650       }
3651
3652    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3653    {
3654       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3655       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3656       {
3657          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3658          return RFAILED;
3659       }
3660    }
3661
3662    tciStateIdx = 0;
3663    /* TODO */
3664    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3665
3666    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3667    if(!controlRset->tci_PresentInDCI)
3668    {
3669       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3670       return RFAILED;
3671    }
3672    /* TODO */
3673    *(controlRset->tci_PresentInDCI);
3674 #endif
3675
3676    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3677    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3678    if(!controlRSet->pdcch_DMRS_ScramblingID)
3679    {
3680       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3681       return RFAILED;
3682    }
3683    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3684
3685    return ROK;
3686 } /* End BuildControlRSetToAddModList */
3687
3688 /*******************************************************************
3689  *
3690  * @brief Build search space to add/modify list
3691  *
3692  * @details
3693  *
3694  *    Function : BuildSearchSpcToAddModList
3695  *
3696  *    Functionality: Build search space to add/modify list
3697  *
3698  * @params[in]
3699  * @return ROK     - success
3700  *         RFAILED - failure
3701  *
3702  * ****************************************************************/
3703    uint8_t BuildSearchSpcToAddModList
3704 (
3705  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3706  )
3707 {
3708    uint8_t idx;
3709    uint8_t numBytes;
3710    uint8_t byteIdx;
3711    uint8_t bitsUnused;
3712    uint8_t elementCnt;
3713    struct SearchSpace *searchSpc;
3714
3715    elementCnt = 1;
3716    searchSpcList->list.count = elementCnt;
3717    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3718
3719    searchSpcList->list.array = NULLP;
3720    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3721    if(!searchSpcList->list.array)
3722    {
3723       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3724       return RFAILED;
3725    }
3726
3727    for(idx = 0; idx < elementCnt; idx++)
3728    {
3729       searchSpcList->list.array[idx] = NULLP;
3730       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3731       if(!searchSpcList->list.array[idx])
3732       {
3733          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3734          return RFAILED;
3735       }
3736    }
3737
3738    idx = 0;
3739    searchSpc = searchSpcList->list.array[idx];
3740
3741    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3742
3743    searchSpc->controlResourceSetId = NULLP;
3744    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3745    if(!searchSpc->controlResourceSetId)
3746    {
3747       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3748       return RFAILED;
3749    }
3750    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3751
3752    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3753    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3754          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3755    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3756    {
3757       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3758       return RFAILED;
3759    }
3760    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3761                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3762
3763    searchSpc->duration = NULLP;
3764    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3765    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3766    if(!searchSpc->monitoringSymbolsWithinSlot)
3767    {
3768       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3769       return RFAILED;
3770    }
3771
3772    /* Values taken from reference logs :
3773     * size 2 bytes
3774     * 2 LSBs unsued
3775     * Bit string stores 8000
3776     */
3777    numBytes = 2;
3778    bitsUnused = 2;
3779
3780    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3781    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3782    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3783          searchSpc->monitoringSymbolsWithinSlot->size);
3784    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3785    {
3786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3787       return RFAILED;
3788    }
3789
3790    byteIdx = 0;
3791    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3792                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3793    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3794    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3795
3796    searchSpc->nrofCandidates = NULLP;
3797    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3798    if(!searchSpc->nrofCandidates)
3799    {
3800       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3801       return RFAILED;
3802    }
3803
3804    searchSpc->nrofCandidates->aggregationLevel1 = \
3805                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3806    searchSpc->nrofCandidates->aggregationLevel2 = \
3807                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3808    searchSpc->nrofCandidates->aggregationLevel4 = \
3809                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3810    searchSpc->nrofCandidates->aggregationLevel8 = \
3811                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3812    searchSpc->nrofCandidates->aggregationLevel16 = \
3813                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3814
3815    searchSpc->searchSpaceType = NULLP;
3816    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3817    if(!searchSpc->searchSpaceType)
3818    {
3819       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3820       return RFAILED;
3821    }
3822
3823    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3824
3825    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3826    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3827          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3828    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3829    {
3830       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3831       return RFAILED;
3832    }
3833    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3834                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3835
3836    return ROK;
3837 }/* End BuildSearchSpcToAddModList */
3838
3839 /*******************************************************************
3840  *
3841  * @brief Builds BWP DL dedicated PDCCH config
3842  *
3843  * @details
3844  *
3845  *    Function : BuildBWPDlDedPdcchCfg
3846  *
3847  *    Functionality: Builds BWP DL dedicated PDCCH config
3848  *
3849  * @params[in] struct PDCCH_Config *pdcchCfg
3850  *
3851  * @return ROK     - success
3852  *         RFAILED - failure
3853  *
3854  * ****************************************************************/
3855 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3856 {
3857    pdcchCfg->controlResourceSetToAddModList = NULLP;
3858    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3859          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3860    if(!pdcchCfg->controlResourceSetToAddModList)
3861    {
3862       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3863       return RFAILED;
3864    }
3865
3866    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3867    {
3868       return RFAILED;
3869    }
3870
3871    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3872
3873    pdcchCfg->searchSpacesToAddModList = NULLP;
3874    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3875          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3876    if(!pdcchCfg->searchSpacesToAddModList)
3877    {
3878       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3879       return RFAILED;
3880    }
3881
3882    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3883    {
3884       return RFAILED;
3885    }
3886
3887    pdcchCfg->searchSpacesToReleaseList = NULLP;
3888    pdcchCfg->downlinkPreemption = NULLP;
3889    pdcchCfg->tpc_PUSCH = NULLP;
3890    pdcchCfg->tpc_PUCCH = NULLP;
3891    pdcchCfg->tpc_SRS = NULLP;
3892
3893    return ROK;
3894 }
3895
3896 /*******************************************************************
3897  *
3898  * @brief Builds DMRS DL PDSCH Mapping type A
3899  *
3900  * @details
3901  *
3902  *    Function : BuildDMRSDLPdschMapTypeA
3903  *
3904  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3905  *
3906  * @params[in]
3907  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3908  * @return ROK     - success
3909  *         RFAILED - failure
3910  *
3911  * ****************************************************************/
3912    uint8_t BuildDMRSDLPdschMapTypeA
3913 (
3914  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3915  )
3916 {
3917    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3918    dmrsDlCfg->choice.setup = NULLP;
3919    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3920    if(!dmrsDlCfg->choice.setup)
3921    {
3922       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3923       return RFAILED;
3924    }
3925
3926    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3927    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3928    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3929    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3930    {
3931       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3932       return RFAILED;
3933    }
3934    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3935
3936    dmrsDlCfg->choice.setup->maxLength = NULLP;
3937    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3938    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3939    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3940
3941    return ROK;
3942 }
3943
3944 /*******************************************************************
3945  *
3946  * @brief Builds TCI states to add/modify list
3947  *
3948  * @details
3949  *
3950  *    Function : BuildTCIStatesToAddModList
3951  *
3952  *    Functionality:Builds TCI states to add/modify list
3953  *
3954  * @params[in]
3955  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3956  *
3957  * @return ROK     - success
3958  *         RFAILED - failure
3959  *
3960  * ****************************************************************/
3961 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3962 {
3963    return ROK;
3964 }
3965
3966 /*******************************************************************
3967  *
3968  * @brief Builds PDSCH time domain allocation list
3969  *
3970  * @details
3971  *
3972  *    Function : BuildPdschTimeDomAllocList
3973  *
3974  *    Functionality: Builds PDSCH time domain allocation list
3975  *
3976  * @params[in]
3977  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3978  *
3979  * @return ROK     - success
3980  *         RFAILED - failure
3981  *
3982  * ****************************************************************/
3983    uint8_t BuildPdschTimeDomAllocList
3984 (
3985  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3986  )
3987 {
3988    uint8_t idx;
3989    uint8_t elementCnt;
3990    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3991
3992    timeDomAllocList->present = \
3993                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3994
3995    timeDomAllocList->choice.setup = NULLP;
3996    CU_ALLOC(timeDomAllocList->choice.setup, \
3997          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3998    if(!timeDomAllocList->choice.setup)
3999    {
4000       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4001       return RFAILED;
4002    }
4003
4004    elementCnt = 2;
4005    timeDomAllocList->choice.setup->list.count = elementCnt;
4006    timeDomAllocList->choice.setup->list.size = \
4007                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4008
4009    timeDomAllocList->choice.setup->list.array = NULLP;
4010    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4011          timeDomAllocList->choice.setup->list.size);
4012    if(!timeDomAllocList->choice.setup->list.array)
4013    {
4014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4015       return RFAILED;
4016    }
4017
4018    for(idx = 0; idx < elementCnt; idx++)
4019    {
4020       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4021       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4022             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4023       if(!timeDomAllocList->choice.setup->list.array[idx])
4024       {
4025          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4026          return RFAILED;
4027       }
4028    }
4029
4030    idx = 0;
4031    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4032    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4033    if(!timeDomAlloc->k0)
4034    {
4035        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4036        return RFAILED;
4037    }
4038    *(timeDomAlloc->k0) = 0;
4039    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4040    timeDomAlloc->startSymbolAndLength = 66;
4041
4042    idx++;
4043    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4044    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4045    if(!timeDomAlloc->k0)
4046    {
4047       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4048       return RFAILED;
4049    }
4050    *(timeDomAlloc->k0) = 1;
4051    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4052    timeDomAlloc->startSymbolAndLength = 66;
4053
4054    return ROK;
4055 }
4056
4057 /*******************************************************************
4058  *
4059  * @brief Builds PDSCH PRB Bundling type
4060  *
4061  * @details
4062  *
4063  *    Function : BuildPdschPrbBundlingType
4064  *
4065  *    Functionality: Builds PDSCH PRB Bundling type
4066  *
4067  * @params[in]
4068  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4069  *
4070  * @return ROK     - success
4071  *         RFAILED - failure
4072  *
4073  * ****************************************************************/
4074    uint8_t BuildPdschPrbBundlingType
4075 (
4076  struct PDSCH_Config__prb_BundlingType *prbBndlType
4077  )
4078 {
4079    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4080
4081    prbBndlType->choice.staticBundling = NULLP;
4082    CU_ALLOC(prbBndlType->choice.staticBundling, \
4083          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4084    if(!prbBndlType->choice.staticBundling)
4085    {
4086       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4087       return RFAILED;
4088    }
4089    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4090
4091    return ROK;
4092 }
4093
4094 /*******************************************************************
4095  *
4096  * @brief Builds BWP DL dedicated PDSCH config
4097  *
4098  * @details
4099  *
4100  *    Function : BuildBWPDlDedPdschCfg
4101  *
4102  *    Functionality: Builds BWP DL dedicated PDSCH config
4103  *
4104  * @params[in] struct PDSCH_Config *pdschCfg
4105  *
4106  * @return ROK     - success
4107  *         RFAILED - failure
4108  *
4109  * ****************************************************************/
4110 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4111 {
4112    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4113
4114    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4115    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4116          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4117    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4118    {
4119       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4120       return RFAILED;
4121    }
4122
4123    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4124    {
4125       return RFAILED;
4126    }
4127
4128    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4129    pdschCfg->tci_StatesToAddModList = NULLP;
4130    pdschCfg->tci_StatesToReleaseList = NULLP;
4131    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4132 #if 0
4133    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4134    if(!pdschCfg->tci_StatesToAddModList)
4135    {
4136       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4137       return RFAILED;
4138    }
4139    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4140    {
4141       return RFAILED;
4142    }
4143 #endif
4144
4145    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4146
4147    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4148    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4149          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4150    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4151    {
4152       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4153       return RFAILED;
4154    }
4155    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4156    {
4157       return RFAILED;
4158    }
4159    pdschCfg->pdsch_AggregationFactor = NULLP;
4160    pdschCfg->rateMatchPatternToAddModList = NULLP;
4161    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4162    pdschCfg->rateMatchPatternGroup1 = NULLP;
4163    pdschCfg->rateMatchPatternGroup2 = NULLP;
4164    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4165    pdschCfg->mcs_Table = NULLP;
4166
4167    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4168    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4169    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4170    {
4171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4172       return RFAILED;
4173    }
4174    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4175
4176    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4177    {
4178       return RFAILED;
4179    }
4180
4181    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4182    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4183    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4184    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4185    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4186    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4187    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4188
4189    return ROK;
4190 }
4191
4192 /*******************************************************************
4193  *
4194  * @brief Builds intitial DL BWP
4195  * @details
4196  *
4197  *    Function : BuildInitialDlBWP
4198  *
4199  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4200  *
4201  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4202  *
4203  * @return ROK     - success
4204  *         RFAILED - failure
4205  *
4206  * ****************************************************************/
4207 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4208 {
4209    dlBwp->pdcch_Config = NULLP;
4210    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4211    if(!dlBwp->pdcch_Config)
4212    {
4213       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4214       return RFAILED;
4215    }
4216    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4217
4218    dlBwp->pdcch_Config->choice.setup = NULLP;
4219    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4220    if(!dlBwp->pdcch_Config->choice.setup)
4221    {
4222       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4223       return RFAILED;
4224    }
4225    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4226    {
4227       return RFAILED;
4228    }
4229
4230    dlBwp->pdsch_Config = NULLP;
4231    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4232    if(!dlBwp->pdsch_Config)
4233    {
4234       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4235       return RFAILED;
4236    }
4237    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4238
4239    dlBwp->pdsch_Config->choice.setup = NULLP;
4240    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4241    if(!dlBwp->pdsch_Config->choice.setup)
4242    {
4243       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4244       return RFAILED;
4245    }
4246
4247    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4248    {
4249       return RFAILED;
4250    }
4251
4252    dlBwp->sps_Config = NULLP;
4253    dlBwp->radioLinkMonitoringConfig = NULLP;
4254    return ROK;
4255 }
4256
4257 /*******************************************************************
4258  *
4259  * @brief Builds DMRS UL Pusch Mapping type A
4260  *
4261  * @details
4262  *
4263  *    Function : BuildDMRSULPuschMapTypeA
4264  *
4265  *    Functionality: Builds DMRS UL Pusch Mapping type A
4266  *
4267  * @params[in]
4268  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4269  * @return ROK     - success
4270  *         RFAILED - failure
4271  *
4272  * ****************************************************************/
4273    uint8_t BuildDMRSULPuschMapTypeA
4274 (
4275  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4276  )
4277 {
4278    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4279    dmrsUlCfg->choice.setup= NULLP;
4280    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4281    if(!dmrsUlCfg->choice.setup)
4282    {
4283       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4284       return RFAILED;
4285    }
4286
4287    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4288    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4289    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4290    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4291    {
4292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4293       return RFAILED;
4294    }
4295    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4296
4297    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4298    dmrsUlCfg->choice.setup->maxLength = NULLP;
4299    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4300    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4301          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4302    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4303    {
4304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4305       return RFAILED;
4306    }
4307
4308    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4309    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4310          sizeof(long));
4311    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4312    {
4313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4314       return RFAILED;
4315    }
4316    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4317
4318    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4319    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4320    return ROK;
4321 }
4322
4323 /*******************************************************************
4324  *
4325  * @brief Build PUSCH time domain allocation list
4326  *
4327  * @details
4328  *
4329  *    Function : BuildPuschTimeDomAllocList
4330  *
4331  *    Functionality: Build PUSCH time domain allocation list
4332  *
4333  * @params[in]
4334  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4335  *
4336  * @return ROK     - success
4337  *         RFAILED - failure
4338  *
4339  * ****************************************************************/
4340    uint8_t BuildPuschTimeDomAllocList
4341 (
4342  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4343  )
4344 {
4345    uint8_t idx;
4346    uint8_t elementCnt;
4347    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4348
4349    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4350    timeDomAllocList->choice.setup = NULLP;
4351    CU_ALLOC(timeDomAllocList->choice.setup, \
4352          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4353    if(!timeDomAllocList->choice.setup)
4354    {
4355       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4356       return RFAILED;
4357    }
4358
4359    elementCnt = 2;
4360    timeDomAllocList->choice.setup->list.count = elementCnt;
4361    timeDomAllocList->choice.setup->list.size = \
4362                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4363    timeDomAllocList->choice.setup->list.array = NULLP;
4364    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4365          timeDomAllocList->choice.setup->list.size);
4366    if(!timeDomAllocList->choice.setup->list.array)
4367    {
4368       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4369       return RFAILED;
4370    }
4371
4372    for(idx = 0; idx < elementCnt; idx++)
4373    {
4374       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4375       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4376             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4377       if(!timeDomAllocList->choice.setup->list.array[idx])
4378       {
4379          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4380          return RFAILED;
4381       }
4382    }
4383
4384    idx = 0;
4385    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4386    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4387    if(!timeDomAlloc->k2)
4388    {
4389       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4390       return RFAILED;
4391    }
4392    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4393    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4394    timeDomAlloc->startSymbolAndLength = 66;
4395
4396    idx++;
4397    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4398    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4399    if(!timeDomAlloc->k2)
4400    {
4401        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4402        return RFAILED;
4403    }
4404    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4405    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4406    timeDomAlloc->startSymbolAndLength = 66;
4407
4408    return ROK;
4409 }
4410
4411 /*******************************************************************
4412  *
4413  * @brief Builds BWP UL dedicated PUSCH Config
4414  *
4415  * @details
4416  *
4417  *    Function : BuildBWPUlDedPuschCfg
4418  *
4419  *    Functionality:
4420  *      Builds BWP UL dedicated PUSCH Config
4421  *
4422  * @params[in] : PUSCH_Config_t *puschCfg
4423  *
4424  * @return ROK     - success
4425  *         RFAILED - failure
4426  *
4427  * ****************************************************************/
4428 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4429 {
4430    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4431    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4432    if(!puschCfg->dataScramblingIdentityPUSCH)
4433    {
4434       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4435       return RFAILED;
4436    }
4437    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4438
4439    puschCfg->txConfig = NULLP;
4440    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4441    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4442          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4443    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4444    {
4445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4446       return RFAILED;
4447    }
4448
4449    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4450    {
4451       return RFAILED;
4452    }
4453
4454    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4455    puschCfg->pusch_PowerControl = NULLP;
4456    puschCfg->frequencyHopping = NULLP;
4457    puschCfg->frequencyHoppingOffsetLists = NULLP;
4458    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4459
4460    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4461    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4462          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4463    if(!puschCfg->pusch_TimeDomainAllocationList)
4464    {
4465       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4466       return RFAILED;
4467    }
4468
4469    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4470    {
4471       return RFAILED;
4472    }
4473
4474    puschCfg->pusch_AggregationFactor = NULLP;
4475    puschCfg->mcs_Table = NULLP;
4476    puschCfg->mcs_TableTransformPrecoder = NULLP;
4477    puschCfg->transformPrecoder = NULLP;
4478    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4479    if(!puschCfg->transformPrecoder)
4480    {
4481       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4482       return RFAILED;
4483    }
4484    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4485
4486    puschCfg->codebookSubset = NULLP;
4487    puschCfg->maxRank = NULLP;
4488    puschCfg->rbg_Size = NULLP;
4489    puschCfg->uci_OnPUSCH = NULLP;
4490    puschCfg->tp_pi2BPSK = NULLP;
4491
4492    return ROK;
4493 }
4494
4495 /*******************************************************************
4496  *
4497  * @brief Builds BWP UL dedicated PUCCH Config
4498  *
4499  * @details
4500  *
4501  *    Function : BuildBWPUlDedPucchCfg
4502  *
4503  *    Functionality:
4504  *      Builds BWP UL dedicated PUCCH Config
4505  *
4506  * @params[in] : PUCCH_Config_t *pucchCfg
4507  *
4508  * @return ROK     - success
4509  *         RFAILED - failure
4510  *
4511  * ****************************************************************/
4512 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4513 {
4514    uint8_t arrIdx, elementCnt;
4515    uint8_t rsrcIdx, rsrcSetIdx;
4516    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4517    PUCCH_Resource_t *rsrc = NULLP;
4518
4519    //RESOURCE SET
4520    elementCnt = 1;
4521    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4522    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4523    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4524    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4525    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4526    {
4527       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4528    }
4529    rsrcSetIdx = 0;
4530    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4531    rsrcSet->pucch_ResourceSetId = 1;
4532    elementCnt = 1;
4533    rsrcSet->resourceList.list.count = elementCnt;
4534    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4535    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4536    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4537    {
4538       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4539    }
4540    rsrcIdx = 0;
4541    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4542
4543    //RESOURCE
4544    elementCnt = 1;
4545    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4546    pucchCfg->resourceToAddModList->list.count = elementCnt;
4547    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4548    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4549    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4550    {
4551       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4552    }
4553    rsrcIdx = 0;
4554    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4555    rsrc->pucch_ResourceId = 1;
4556    rsrc->startingPRB = 0;
4557    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4558    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4559    rsrc->format.choice.format1->initialCyclicShift = 0;
4560    rsrc->format.choice.format1->nrofSymbols = 4;
4561    rsrc->format.choice.format1->startingSymbolIndex = 0;
4562    rsrc->format.choice.format1->timeDomainOCC = 0;
4563
4564    //PUCCH Format 1
4565    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4566    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4567    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4568    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4569    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4570
4571    //DL DATA TO UL ACK
4572    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4573    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4574    {
4575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4576       return RFAILED;
4577    }
4578
4579    elementCnt = 2;
4580    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4581    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4582    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4583    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4584    {
4585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4586       return RFAILED;
4587    }
4588
4589    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4590    {
4591       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4592       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4593       {
4594           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4595           return RFAILED;
4596       }
4597    }
4598
4599    arrIdx = 0;
4600    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4601    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4602
4603    return ROK;
4604 }
4605
4606 /*******************************************************************
4607  *
4608  * @brief Fills SRS resource to add/modify list
4609  *
4610  * @details
4611  *
4612  *    Function : BuildSrsRsrcAddModList
4613  *
4614  *    Functionality: Fills SRS resource to add/modify list
4615  *
4616  * @params[in]
4617  * @return ROK     - success
4618  *         RFAILED - failure
4619  *
4620  * ****************************************************************/
4621 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4622 {
4623    uint8_t   elementCnt;
4624    uint8_t   rsrcIdx;
4625
4626    elementCnt = 1;
4627    resourceList->list.count = elementCnt;
4628    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4629    resourceList->list.array = NULLP;
4630    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4631    if(!resourceList->list.array)
4632    {
4633       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4634       return RFAILED;
4635    }
4636
4637    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4638    {
4639       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4640       if(!resourceList->list.array[rsrcIdx])
4641       {
4642          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4643          return RFAILED;
4644       }
4645    }
4646
4647    rsrcIdx = 0;
4648    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4649    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4650    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4651
4652    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4653    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4654          sizeof(struct SRS_Resource__transmissionComb__n2));
4655    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4656    {
4657       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4658       return RFAILED;
4659    }
4660    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4661       = SRS_COMB_OFFSET_N2;
4662    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4663       = SRS_CYCLIC_SHIFT_N2;
4664
4665    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4666    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4667                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4668    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4669                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4670
4671    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4672    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4673    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4674    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4675    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4676    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4677                                                                SRS_Resource__groupOrSequenceHopping_neither;
4678
4679    /* Setting resource type to aperiodic for intergration purposes */
4680    resourceList->list.array[rsrcIdx]->resourceType.present = \
4681                                                              SRS_Resource__resourceType_PR_aperiodic;
4682    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4683    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4684          sizeof(struct SRS_Resource__resourceType__aperiodic));
4685    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4686    {
4687       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4688       return RFAILED;
4689    }
4690    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4691
4692    return ROK;
4693 }
4694
4695 /*******************************************************************
4696  *
4697  * @brief Build SRS resource set Add/mod list
4698  *
4699  * @details
4700  *
4701  *    Function : BuildSrsRsrcSetAddModList
4702  *
4703  *    Functionality: Build SRS resource set Add/mod list
4704  *
4705  * @params[in]
4706  * @return ROK     - success
4707  *         RFAILED - failure
4708  *
4709  * ****************************************************************/
4710    uint8_t BuildSrsRsrcSetAddModList
4711 (
4712  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4713  )
4714 {
4715    uint8_t  elementCnt;
4716    uint8_t  rSetIdx;
4717    uint8_t  rsrcIdx;
4718    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4719
4720    elementCnt = 1;
4721    rsrcSetList->list.count = elementCnt;
4722    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4723    rsrcSetList->list.array = NULLP;
4724    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4725    if(!rsrcSetList->list.array)
4726    {
4727       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4728       return RFAILED;
4729    }
4730
4731    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4732    {
4733       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4734       if(!rsrcSetList->list.array[rSetIdx])
4735       {
4736          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4737          return RFAILED;
4738       }
4739    }
4740
4741    rSetIdx = 0;
4742    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4743
4744    /* Fill Resource Id list in resource set */
4745    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4746    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4747          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4748    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4749    {
4750       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4751       return RFAILED;
4752    }
4753
4754    elementCnt = 1;
4755    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4756    rsrcIdList->list.count = elementCnt;
4757    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4758    rsrcIdList->list.array = NULLP;
4759    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4760    if(!rsrcIdList->list.array)
4761    {
4762       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4763       return RFAILED;
4764    }
4765
4766    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4767    {
4768       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4769       if(!rsrcIdList->list.array[rsrcIdx])
4770       {
4771          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4772          return RFAILED;
4773       }
4774    }
4775
4776    rsrcIdx = 0;
4777    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4778
4779    /* Fill resource type */
4780    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4781                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4782
4783    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4784    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4785          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4786    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4787    {
4788       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4789       return RFAILED;
4790    }
4791    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4792       = APERIODIC_SRS_RESRC_TRIGGER;
4793
4794    /* TODO : Fill values for below IEs as expected by Viavi */
4795    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4796    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4797
4798
4799    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4800    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4801    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4802    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4803    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4804
4805    return ROK;
4806 }
4807
4808 /*******************************************************************
4809  *
4810  * @brief Builds BWP UL dedicated SRS Config
4811  *
4812  * @details
4813  *
4814  *    Function : BuildBWPUlDedSrsCfg
4815  *
4816  *    Functionality: Builds BWP UL dedicated SRS Config
4817  *
4818  * @params[in] SRS Config
4819  * @return ROK     - success
4820  *         RFAILED - failure
4821  *
4822  * ****************************************************************/
4823 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4824 {
4825    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4826    srsCfg->srs_ResourceSetToAddModList = NULLP;
4827    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4828          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4829    if(!srsCfg->srs_ResourceSetToAddModList)
4830    {
4831       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4832       return RFAILED;
4833    }
4834    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4835    {
4836       return RFAILED;
4837    }
4838
4839    srsCfg->srs_ResourceToReleaseList = NULLP;
4840
4841    /* Resource to Add/Modify list */
4842    srsCfg->srs_ResourceToAddModList = NULLP;
4843    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4844          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4845    if(!srsCfg->srs_ResourceToAddModList)
4846    {
4847       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4848       return RFAILED;
4849    }
4850
4851    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4852    {
4853       return RFAILED;
4854    }
4855
4856    srsCfg->tpc_Accumulation = NULLP;
4857
4858    return ROK;
4859 }
4860
4861 /*******************************************************************
4862  *
4863  * @brief Builds inital UL BWP
4864  *
4865  * @details
4866  *
4867  *    Function : BuildInitialUlBWP
4868  *
4869  *    Functionality: Builds initial UL BWP
4870  *
4871  * @params[in] BWP_UplinkDedicated_t *ulBwp
4872  * @return ROK     - success
4873  *         RFAILED - failure
4874  *
4875  * ****************************************************************/
4876 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4877 {
4878    ulBwp->pucch_Config = NULLP;
4879    ulBwp->pucch_Config = NULLP;
4880    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4881    if(!ulBwp->pucch_Config)
4882    {
4883       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4884       return RFAILED;
4885    }
4886
4887    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4888    ulBwp->pucch_Config->choice.setup = NULLP;
4889    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4890    if(!ulBwp->pucch_Config->choice.setup)
4891    {
4892       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4893       return RFAILED;
4894    }
4895
4896    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4897    {
4898       return RFAILED;
4899    }
4900
4901    /* Fill BWP UL dedicated PUSCH config */
4902    ulBwp->pusch_Config = NULLP;
4903    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4904    if(!ulBwp->pusch_Config)
4905    {
4906       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4907       return RFAILED;
4908    }
4909
4910    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4911    ulBwp->pusch_Config->choice.setup = NULLP;
4912    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4913    if(!ulBwp->pusch_Config->choice.setup)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4916       return RFAILED;
4917    }
4918
4919    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4920    {
4921       return RFAILED;
4922    }
4923
4924    ulBwp->configuredGrantConfig = NULLP;
4925
4926    /* Fill BPW UL dedicated SRS config */
4927    ulBwp->srs_Config = NULLP;
4928    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4929    if(!ulBwp->srs_Config)
4930    {
4931       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4932       return RFAILED;
4933    }
4934
4935    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4936    ulBwp->srs_Config->choice.setup = NULLP;
4937    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4938    if(!ulBwp->srs_Config->choice.setup)
4939    {
4940       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4941       return RFAILED;
4942    }
4943
4944    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4945    {
4946       return RFAILED;
4947    }
4948
4949    ulBwp->beamFailureRecoveryConfig = NULLP;
4950
4951    return ROK;
4952 }
4953
4954 /*******************************************************************
4955  *
4956  * @brief Builds Pusch Serving cell Config
4957  *
4958  * @details
4959  *
4960  *    Function : BuildPuschSrvCellCfg
4961  *
4962  *    Functionality: Builds Pusch Serving cell Config
4963  *
4964  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4965  *
4966  * @return ROK     - success
4967  *         RFAILED - failure
4968  *
4969  * ****************************************************************/
4970 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4971 {
4972    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4973    puschCfg->choice.setup = NULLP;
4974    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4975    if(!puschCfg->choice.setup)
4976    {
4977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4978       return RFAILED;
4979    }
4980
4981    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4982    puschCfg->choice.setup->rateMatching = NULLP;
4983    puschCfg->choice.setup->xOverhead = NULLP;
4984    puschCfg->choice.setup->ext1 = NULLP;
4985    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4986    if(!puschCfg->choice.setup->ext1)
4987    {
4988       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4989       return RFAILED;
4990    }
4991
4992    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4993    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4994    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4995    {
4996       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4997       return RFAILED;
4998    }
4999    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5000
5001    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5002    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5003    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5004    {
5005       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5006       return RFAILED;
5007    }
5008    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5009    return ROK;
5010 }
5011
5012 /*******************************************************************
5013  *
5014  * @brief Builds UL config
5015  * @details
5016  *
5017  *    Function : BuildUlCfg
5018  *
5019  *    Functionality: Builds UL config in spCellCfgDed
5020  *
5021  * @params[in] UplinkConfig_t *ulCfg
5022  *
5023  * @return ROK     - success
5024  *         RFAILED - failure
5025  *
5026  * ****************************************************************/
5027 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
5028 {
5029    ulCfg->initialUplinkBWP = NULLP;
5030    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5031    if(!ulCfg->initialUplinkBWP)
5032    {
5033       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5034       return RFAILED;
5035    }
5036
5037    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
5038    {
5039       return RFAILED;
5040    }
5041
5042    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5043    ulCfg->uplinkBWP_ToAddModList = NULLP;
5044    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5045    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5046    if(!ulCfg->firstActiveUplinkBWP_Id)
5047    {
5048       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5049       return RFAILED;
5050    }
5051    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5052
5053    ulCfg->pusch_ServingCellConfig = NULLP;
5054    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
5055          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5056    if(!ulCfg->pusch_ServingCellConfig)
5057    {
5058       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5059       return RFAILED;
5060    }
5061
5062    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5063    {
5064       return RFAILED;
5065    }
5066
5067    ulCfg->carrierSwitching = NULLP;
5068    ulCfg->ext1 = NULLP;
5069    return ROK;
5070 }
5071
5072 /*******************************************************************
5073  *
5074  * @brief Builds PDSCH serving cell config
5075  * @details
5076  *
5077  *    Function : BuildPdschSrvCellCfg
5078  *
5079  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5080  *
5081  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5082  *
5083  * @return ROK     - success
5084  *         RFAILED - failure
5085  *
5086  * ****************************************************************/
5087 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5088 {
5089    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5090    pdschCfg->choice.setup = NULLP;
5091    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5092    if(!pdschCfg->choice.setup)
5093    {
5094       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5095       return RFAILED;
5096    }
5097
5098    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5099    pdschCfg->choice.setup->xOverhead = NULLP;
5100    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5101    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5102    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5103    {
5104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5105       return RFAILED;
5106    }
5107    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5108    pdschCfg->choice.setup->pucch_Cell = NULLP;
5109    pdschCfg->choice.setup->ext1 = NULLP;
5110
5111    return ROK;
5112 }
5113
5114 /*******************************************************************
5115  *
5116  * @brief Builds CSI Meas config
5117  * @details
5118  *
5119  *    Function : BuildCsiMeasCfg
5120  *
5121  *    Functionality: Builds CSI Meas config in spCellCfgDed
5122  *
5123  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5124  *
5125  * @return ROK     - success
5126  *         RFAILED - failure
5127  *
5128  * ****************************************************************/
5129 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5130 {
5131
5132    return ROK;
5133 }
5134
5135 /*******************************************************************
5136  *
5137  * @brief Builds Spcell config dedicated
5138  * @details
5139  *
5140  *    Function : BuildSpCellCfgDed
5141  *
5142  *    Functionality: Builds sp cell config dedicated in spCellCfg
5143  *
5144  * @params[in] ServingCellConfig_t srvCellCfg
5145  *
5146  * @return ROK     - success
5147  *         RFAILED - failure
5148  *
5149  * ****************************************************************/
5150 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5151 {
5152    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5153
5154    srvCellCfg->initialDownlinkBWP = NULLP;
5155    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5156    if(!srvCellCfg->initialDownlinkBWP)
5157    {
5158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5159       return RFAILED;
5160    }
5161
5162    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5163    {
5164       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5165       return RFAILED;
5166    }
5167    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5168    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5169
5170    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5171    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5172    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5173    {
5174       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5175       return RFAILED;
5176    }
5177    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5178
5179    srvCellCfg->bwp_InactivityTimer = NULLP;
5180
5181    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5182    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5183    if(!srvCellCfg->defaultDownlinkBWP_Id)
5184    {
5185       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5186       return RFAILED;
5187    }
5188    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5189
5190    srvCellCfg->uplinkConfig = NULLP;
5191    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5192    if(!srvCellCfg->uplinkConfig)
5193    {
5194       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5195       return RFAILED;
5196    }
5197
5198    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5199    {
5200       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5201       return RFAILED;
5202    }
5203    srvCellCfg->supplementaryUplink = NULLP;
5204    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5205
5206    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5207    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5208    if(!srvCellCfg->pdsch_ServingCellConfig)
5209    {
5210       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5211       return RFAILED;
5212    }
5213
5214    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5215    {
5216       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5217       return RFAILED;
5218    }
5219
5220    srvCellCfg->csi_MeasConfig = NULLP;
5221 #if 0
5222    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5223       if(!srvCellCfg->csi_MeasConfig)
5224       {
5225          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5226          return RFAILED;
5227       }
5228
5229    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5230    {
5231       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5232       return RFAILED;
5233    }
5234 #endif
5235    srvCellCfg->sCellDeactivationTimer = NULLP;
5236    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5237    srvCellCfg->tag_Id = TAG_ID;
5238    srvCellCfg->dummy = NULLP;
5239    srvCellCfg->pathlossReferenceLinking = NULLP;
5240    srvCellCfg->servingCellMO = NULLP;
5241    srvCellCfg->ext1 = NULLP;
5242
5243    return ROK;
5244 }
5245 /*******************************************************************
5246  *
5247  * @brief Builds Spcell config
5248  *
5249  * @details
5250  *
5251  *    Function : BuildSpCellCfg
5252  *
5253  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5254  *
5255  * @params[in] SpCellConfig_t spCellCfg
5256  *
5257  * @return ROK     - success
5258  *         RFAILED - failure
5259  *
5260  * ****************************************************************/
5261 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5262 {
5263
5264    spCellCfg->servCellIndex = NULLP;
5265    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5266    if(!spCellCfg->servCellIndex)
5267    {
5268       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5269       return RFAILED;
5270    }
5271    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5272
5273    spCellCfg->reconfigurationWithSync = NULLP;
5274    spCellCfg->rlf_TimersAndConstants = NULLP;
5275    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5276    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5277    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5278    {
5279       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5280       return RFAILED;
5281    }
5282    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5283
5284    spCellCfg->spCellConfigDedicated = NULLP;
5285    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5286    if(!spCellCfg->spCellConfigDedicated)
5287    {
5288       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5289       return RFAILED;
5290    }
5291    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5292    {
5293       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5294       return RFAILED;
5295    }
5296    return ROK;
5297 }
5298 /*******************************************************************
5299  *
5300  * @brief Builds Phy cell group config
5301  *
5302  * @details
5303  *
5304  *    Function : BuildPhyCellGrpCfg
5305  *
5306  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5307  *
5308  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5309  *
5310  * @return ROK     - success
5311  *         RFAILED - failure
5312  *
5313  * ****************************************************************/
5314 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5315 {
5316    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5317    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5318
5319    phyCellGrpCfg->p_NR_FR1 = NULLP;
5320    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5321    if(!phyCellGrpCfg->p_NR_FR1)
5322    {
5323       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5324       return RFAILED;
5325    }
5326    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5327    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5328    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5329    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5330    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5331    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5332    phyCellGrpCfg->cs_RNTI = NULLP;
5333    phyCellGrpCfg->ext1 = NULLP;
5334    phyCellGrpCfg->ext2 = NULLP;
5335
5336    return ROK;
5337 }
5338
5339 /*******************************************************************
5340  *
5341  * @brief Builds tag config
5342  *
5343  * @details
5344  *
5345  *    Function : BuildTagConfig
5346  *
5347  *    Functionality: Builds tag config in MacCellGroupConfig
5348  *
5349  * @params[in] TAG_Config *tag_Config
5350  *
5351  * @return ROK     - success
5352  *         RFAILED - failure
5353  *
5354  * ****************************************************************/
5355 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5356 {
5357    struct TAG_Config__tag_ToAddModList *tagList;
5358    uint8_t                     idx, elementCnt;
5359
5360    tagConfig->tag_ToReleaseList = NULLP;
5361    tagConfig->tag_ToAddModList = NULLP;
5362    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5363    if(!tagConfig->tag_ToAddModList)
5364    {
5365       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5366       return RFAILED;
5367    }
5368
5369    elementCnt = 1; //ODU_VALUE_ONE;
5370    tagList = tagConfig->tag_ToAddModList;
5371    tagList->list.count = elementCnt;
5372    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5373
5374    tagList->list.array = NULLP;
5375    CU_ALLOC(tagList->list.array, tagList->list.size);
5376    if(!tagList->list.array)
5377    {
5378       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5379       return RFAILED;
5380    }
5381
5382    for(idx=0; idx<tagList->list.count; idx++)
5383    {
5384       tagList->list.array[idx] = NULLP;
5385       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5386       if(!tagList->list.array[idx])
5387       {
5388          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5389          return RFAILED;
5390       }
5391    }
5392
5393    idx = 0;
5394    tagList->list.array[idx]->tag_Id = TAG_ID;
5395    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5396
5397    return ROK;
5398 }
5399
5400 /*******************************************************************
5401  *
5402  * @brief Builds PHR Config
5403  *
5404  * @details
5405  *
5406  *    Function : BuildPhrConfig
5407  *
5408  *    Functionality: Builds phrConfig in MacCellGroupConfig
5409  *
5410  * @params[in] PHR Config *
5411  *
5412  * @return ROK     - success
5413  *         RFAILED - failure
5414  *
5415  * ****************************************************************/
5416 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5417 {
5418
5419    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5420    phrConfig->choice.setup = NULLP;
5421    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5422    if(!phrConfig->choice.setup)
5423    {
5424       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5425       return RFAILED;
5426    }
5427
5428    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5429    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5430    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5431    phrConfig->choice.setup->multiplePHR              = false;
5432    phrConfig->choice.setup->dummy                    = false;
5433    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5434    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5435
5436    return ROK;
5437 }
5438
5439 /*******************************************************************
5440  *
5441  * @brief Builds BSR Config
5442  *
5443  * @details
5444  *
5445  *    Function : BuildBsrConfig
5446  *
5447  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5448  *
5449  * @params[in] BSR_Config *bsrConfig
5450  *
5451  * @return ROK     - success
5452  *         RFAILED - failure
5453  *
5454  * ****************************************************************/
5455 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5456 {
5457    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5458    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5459    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5460
5461    return ROK;
5462 }
5463
5464 /*******************************************************************
5465  *
5466  * @brief Builds scheduling request config
5467  *
5468  * @details
5469  *
5470  *    Function : BuildSchedulingReqConfig
5471  *
5472  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5473  *
5474  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5475  *
5476  * @return ROK     - success
5477  *         RFAILED - failure
5478  *
5479  * ****************************************************************/
5480 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5481 {
5482    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5483    uint8_t                     idx, elementCnt;
5484
5485    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5486    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5487          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5488    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5489    {
5490       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5491       return RFAILED;
5492    }
5493
5494    elementCnt = 1; //ODU_VALUE_ONE;
5495    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5496    schReqList->list.count = elementCnt;
5497    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5498
5499    schReqList->list.array = NULLP;
5500    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5501    if(!schReqList->list.array)
5502    {
5503       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5504       return RFAILED;
5505    }
5506
5507    for(idx=0;idx<schReqList->list.count; idx++)
5508    {
5509       schReqList->list.array[idx] = NULLP;
5510       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5511       if(!schReqList->list.array[idx])
5512       {
5513          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5514          return RFAILED;
5515       }
5516    }
5517
5518    idx = 0;
5519    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5520
5521    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5522    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5523    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5524    {
5525       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5526       return RFAILED;
5527    }
5528    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5529    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5530    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5531
5532    return ROK;
5533 }
5534 /*******************************************************************
5535  *
5536  * @brief Builds Mac cell group config
5537  *
5538  * @details
5539  *
5540  *    Function : BuildMacCellGrpCfg
5541  *
5542  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5543  *
5544  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5545  *
5546  * @return ROK     - success
5547  *         RFAILED - failure
5548  *
5549  * ****************************************************************/
5550 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5551 {
5552    macCellGrpCfg->drx_ConfigRrc = NULLP;
5553    macCellGrpCfg->schedulingRequestConfig = NULLP;
5554    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5555    if(!macCellGrpCfg->schedulingRequestConfig)
5556    {
5557       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5558       return RFAILED;
5559    }
5560
5561    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5562    {
5563       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5564       return RFAILED;
5565    }
5566
5567    macCellGrpCfg->bsr_Config = NULLP;
5568    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5569    if(!macCellGrpCfg->bsr_Config)
5570    {
5571       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5572       return RFAILED;
5573    }
5574
5575    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5576    {
5577       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5578       return RFAILED;
5579    }
5580
5581    macCellGrpCfg->tag_Config = NULLP;
5582    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5583    if(!macCellGrpCfg->tag_Config)
5584    {
5585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5586       return RFAILED;
5587    }
5588
5589    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5590    {
5591       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5592       return RFAILED;
5593    }
5594
5595    macCellGrpCfg->phr_Config = NULLP;
5596    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5597    if(!macCellGrpCfg->phr_Config)
5598    {
5599       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5600       return RFAILED;
5601    }
5602
5603    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5604    {
5605       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5606       return RFAILED;
5607    }
5608
5609    macCellGrpCfg->skipUplinkTxDynamic = false;
5610    macCellGrpCfg->ext1 = NULLP;
5611
5612    return ROK;
5613 }
5614 /*******************************************************************
5615  *
5616  * @brief Frees memeory allocated for SearchSpcToAddModList
5617  *
5618  * @details
5619  *
5620  *    Function : FreeSearchSpcToAddModList
5621  *
5622  *    Functionality: Deallocating memory of SearchSpcToAddModList
5623  *
5624  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5625  *
5626  * @return void
5627  *
5628  4221 * ****************************************************************/
5629 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5630 {
5631    uint8_t idx1=0;
5632    uint8_t idx2=0;
5633    struct  SearchSpace *searchSpc=NULLP;
5634
5635    if(searchSpcList->list.array)
5636    {
5637       if(searchSpcList->list.array[idx2])
5638       {
5639          searchSpc = searchSpcList->list.array[idx2];
5640          if(searchSpc->controlResourceSetId)
5641          {
5642             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5643             {
5644                if(searchSpc->monitoringSymbolsWithinSlot)
5645                {
5646                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5647                   {
5648                      if(searchSpc->nrofCandidates)
5649                      {
5650                         if(searchSpc->searchSpaceType)
5651                         {
5652                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5653                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5654                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5655                                     SearchSpace__searchSpaceType));
5656                         }
5657                         CU_FREE(searchSpc->nrofCandidates,
5658                               sizeof(struct SearchSpace__nrofCandidates));
5659                      }
5660                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5661                            searchSpc->monitoringSymbolsWithinSlot->size);
5662                   }
5663                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5664                         sizeof(BIT_STRING_t));
5665                }
5666                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5667                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5668             }
5669             CU_FREE(searchSpc->controlResourceSetId,
5670                   sizeof(ControlResourceSetId_t));
5671          }
5672       }
5673       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5674       {
5675          CU_FREE(searchSpcList->list.array[idx1],
5676                sizeof(struct SearchSpace));
5677       }
5678       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5679    }
5680 }
5681 /*******************************************************************
5682  *
5683  * @brief Frees memory allocated for PdschTimeDomAllocList
5684  *
5685  * @details
5686  *
5687  *    Function : FreePdschTimeDomAllocList
5688  *
5689  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5690  *
5691  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5692  *
5693  * @return void
5694  *
5695  4221 * ****************************************************************/
5696 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5697 {
5698    uint8_t idx1=0;
5699
5700    if(timeDomAllocList->choice.setup)
5701    {
5702       if(timeDomAllocList->choice.setup->list.array)
5703       {
5704          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5705          {
5706             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5707                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5708          }
5709          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5710                timeDomAllocList->choice.setup->list.size);
5711       }
5712       CU_FREE(timeDomAllocList->choice.setup,\
5713             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5714    }
5715 }
5716 /*******************************************************************
5717  *
5718  * @brief Frees memory allocated for PuschTimeDomAllocList
5719  *
5720  *@details
5721  *
5722  *    Function : FreePuschTimeDomAllocList
5723  *
5724  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5725  *
5726  * @params[in] PUSCH_Config_t *puschCfg
5727  *
5728  * @return void
5729  *
5730  ***********************************************************************/
5731 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5732 {
5733    uint8_t idx1=0;
5734    uint8_t idx2=0;
5735    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5736
5737    if(puschCfg->pusch_TimeDomainAllocationList)
5738    {
5739       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5740       if(timeDomAllocList_t->choice.setup)
5741       {
5742          if(timeDomAllocList_t->choice.setup->list.array)
5743          {
5744             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5745             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5746             {
5747                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5748                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5749             }
5750             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5751                   timeDomAllocList_t->choice.setup->list.size);
5752          }
5753          CU_FREE(timeDomAllocList_t->choice.setup, \
5754                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5755       }
5756       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5757       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5758             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5759    }
5760
5761 }
5762
5763 /*******************************************************************
5764  *
5765  * @brief Frees memory allocated for Dedicated PUCCH config
5766  *
5767  * @details
5768  *
5769  *    Function : FreeBWPUlDedPucchCfg
5770  *
5771  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5772  *
5773  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5774  *
5775  * @return void
5776  *
5777  * ****************************************************************/
5778 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5779 {
5780    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5781    PUCCH_Config_t *pucchCfg = NULLP;
5782    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5783    PUCCH_Resource_t *rsrc = NULLP;
5784
5785    if(ulBwpPucchCfg)
5786    {
5787       if(ulBwpPucchCfg->choice.setup)
5788       {
5789          pucchCfg = ulBwpPucchCfg->choice.setup;
5790
5791          //Free resource set list
5792          if(pucchCfg->resourceSetToAddModList)
5793          {
5794             if(pucchCfg->resourceSetToAddModList->list.array)
5795             {
5796                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5797                {
5798                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5799                   if(rsrcSet->resourceList.list.array)
5800                   {
5801                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5802                      {
5803                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5804                      }
5805                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5806                   }
5807                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5808                }
5809                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5810             }
5811             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5812          }
5813
5814          //Free resource list
5815          if(pucchCfg->resourceToAddModList)
5816          {
5817             if(pucchCfg->resourceToAddModList->list.array)
5818             {
5819                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5820                {
5821                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5822                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5823                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5824                }
5825                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5826             }
5827             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5828          }
5829
5830          //PUCCH Format 1
5831          if(pucchCfg->format1)
5832          {
5833             if(pucchCfg->format1->choice.setup)
5834             {
5835                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5836                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5837             }
5838             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5839          }
5840
5841          //DL DATA TO UL ACK
5842          if(pucchCfg->dl_DataToUL_ACK)
5843          {
5844             if(pucchCfg->dl_DataToUL_ACK->list.array)
5845             {
5846                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5847                {
5848                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5849                }
5850                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5851             }
5852             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5853          }
5854
5855          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5856       }
5857       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5858    }
5859 }
5860
5861 /*******************************************************************
5862  *
5863  * @brief Frees memory allocated for InitialUlBWP
5864  *
5865  * @details
5866  *
5867  *    Function : FreeInitialUlBWP
5868  *
5869  *    Functionality: Deallocating memory of InitialUlBWP
5870  *
5871  * @params[in] BWP_UplinkDedicated_t *ulBwp
5872  *
5873  * @return void
5874  *
5875  * ****************************************************************/
5876 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5877 {
5878    uint8_t  rSetIdx, rsrcIdx;
5879    SRS_Config_t   *srsCfg = NULLP;
5880    PUSCH_Config_t *puschCfg = NULLP;
5881    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5882    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5883    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5884    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5885
5886    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5887
5888    if(ulBwp->pusch_Config)
5889    {
5890       if(ulBwp->pusch_Config->choice.setup)
5891       {
5892          puschCfg=ulBwp->pusch_Config->choice.setup;
5893          if(puschCfg->dataScramblingIdentityPUSCH)
5894          {
5895             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5896             {
5897                FreePuschTimeDomAllocList(puschCfg);
5898                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5899                if(dmrsUlCfg->choice.setup)
5900                {
5901                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5902                   {
5903                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5904                      {
5905                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5906                               sizeof(long));
5907                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5908                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5909                      }
5910                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5911                            sizeof(long));
5912                   }
5913                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5914                }
5915                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5916                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5917             }
5918             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5919          }
5920          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5921       }
5922       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5923
5924       /* Free SRS-Config */
5925       if(ulBwp->srs_Config)
5926       {
5927          if(ulBwp->srs_Config->choice.setup)
5928          {
5929             srsCfg = ulBwp->srs_Config->choice.setup;
5930
5931             /* Free Resource Set to add/mod list */
5932             if(srsCfg->srs_ResourceSetToAddModList)
5933             {
5934                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5935                if(rsrcSetList->list.array)
5936                {
5937                   rSetIdx = 0;
5938
5939                   /* Free SRS resource Id list in this SRS resource set */
5940                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5941                   {
5942                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5943
5944                      if(rsrcIdList->list.array)
5945                      {
5946                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5947                         {
5948                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5949                         }
5950                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5951                      }
5952                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5953                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5954                   }
5955
5956                   /* Free resource type info for this SRS resource set */
5957                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5958                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5959
5960                   /* Free memory for each resource set */
5961                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5962                   {
5963                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5964                   }
5965                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5966                }
5967                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5968                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5969             }
5970
5971             /* Free resource to add/modd list */
5972             if(srsCfg->srs_ResourceToAddModList)
5973             {
5974                resourceList = srsCfg->srs_ResourceToAddModList;
5975                if(resourceList->list.array)
5976                {
5977                   rsrcIdx = 0;
5978                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5979                         sizeof(struct SRS_Resource__transmissionComb__n2));
5980                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5981                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5982
5983                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5984                   {
5985                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5986                   }
5987                   CU_FREE(resourceList->list.array, resourceList->list.size);
5988                }
5989                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5990                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5991             }
5992
5993             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5994          }
5995          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5996       }
5997    }
5998 }
5999 /*******************************************************************
6000  *
6001  * @brief Frees memory allocated for initialUplinkBWP
6002  *
6003  * @details
6004  *
6005  *    Function : FreeinitialUplinkBWP
6006  *
6007  *    Functionality: Deallocating memory of initialUplinkBWP
6008  *
6009  * @params[in] UplinkConfig_t *ulCfg
6010  *
6011  * @return void
6012  *
6013  *
6014  * ****************************************************************/
6015 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
6016 {
6017    BWP_UplinkDedicated_t *ulBwp=NULLP;
6018    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6019
6020    if(ulCfg->initialUplinkBWP)
6021    {
6022       ulBwp=ulCfg->initialUplinkBWP;
6023       if(ulCfg->firstActiveUplinkBWP_Id)
6024       {
6025          if(ulCfg->pusch_ServingCellConfig)
6026          {
6027             puschCfg=ulCfg->pusch_ServingCellConfig;
6028             if(puschCfg->choice.setup)
6029             {
6030                if(puschCfg->choice.setup->ext1)
6031                {
6032                   CU_FREE(puschCfg->choice.setup->ext1->\
6033                         processingType2Enabled,sizeof(BOOLEAN_t));
6034                   CU_FREE(puschCfg->choice.setup->ext1->\
6035                         maxMIMO_Layers,sizeof(long));
6036                   CU_FREE(puschCfg->choice.setup->ext1, \
6037                         sizeof(struct PUSCH_ServingCellConfig__ext1));
6038                }
6039                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6040             }
6041             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6042          }
6043          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6044       }
6045       FreeInitialUlBWP(ulBwp);
6046       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6047    }
6048 }
6049 /*******************************************************************
6050  *
6051  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6052  *
6053  * @details
6054  *
6055  *    Function : FreeBWPDlDedPdschCfg
6056  *
6057  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6058  *
6059  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6060  *
6061  * @return void
6062  *
6063  *
6064  * ****************************************************************/
6065 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6066 {
6067    struct PDSCH_Config *pdschCfg=NULLP;
6068    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6069    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6070    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6071
6072    if(dlBwp->pdsch_Config->choice.setup)
6073    {
6074       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6075       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6076       {
6077          if(pdschCfg->pdsch_TimeDomainAllocationList)
6078          {
6079             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6080             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6081             {
6082                prbBndlType=&pdschCfg->prb_BundlingType;
6083                CU_FREE(prbBndlType->choice.staticBundling,\
6084                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6085                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6086             }
6087             FreePdschTimeDomAllocList(timeDomAllocList);
6088             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6089                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6090          }
6091          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6092          if(dmrsDlCfg->choice.setup)
6093          {
6094             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6095                   sizeof(long));
6096             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6097          }
6098          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6099                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6100       }
6101       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6102    }
6103 }
6104 /*******************************************************************
6105  *
6106  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6107  *
6108  * @details
6109  *
6110  *    Function : FreeBWPDlDedPdcchCfg
6111  *
6112  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6113  *
6114  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6115  *
6116  * @return void
6117  *
6118  *
6119  * ****************************************************************/
6120 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6121 {
6122    uint8_t idx1=0;
6123    uint8_t idx2=0;
6124    struct PDCCH_Config *pdcchCfg=NULLP;
6125    struct ControlResourceSet *controlRSet=NULLP;
6126    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6127
6128    if(dlBwp->pdcch_Config->choice.setup)
6129    {
6130       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6131       if(pdcchCfg->controlResourceSetToAddModList)
6132       {
6133          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6134          if(controlRSetList->list.array)
6135          {
6136             controlRSet = controlRSetList->list.array[idx2];
6137             if(controlRSet)
6138             {
6139                if(controlRSet->frequencyDomainResources.buf)
6140                {
6141                   if(controlRSet->pdcch_DMRS_ScramblingID)
6142                   {
6143                      if(pdcchCfg->searchSpacesToAddModList)
6144                      {
6145                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6146                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
6147                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6148                      }
6149                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6150                   }
6151                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
6152                         controlRSet->frequencyDomainResources.size);
6153                }
6154             }
6155             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6156             {
6157                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6158             }
6159             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6160          }
6161          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6162                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6163       }
6164       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6165    }
6166 }
6167 /*******************************************************************
6168  *
6169  * @brief Builds RLC Config
6170  *
6171  * @details
6172  *
6173  *    Function : BuildRlcConfig
6174  *
6175  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
6176  *
6177  * @params[in] RLC_Config *rlcConfig
6178  *
6179  * @return ROK     - success
6180  *         RFAILED - failure
6181  *
6182  * ****************************************************************/
6183 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
6184 {
6185    rlcConfig->present = rlcLcCfgDb.rlcMode;
6186
6187    switch(rlcConfig->present)
6188    {
6189       case RLC_Config_PR_am:
6190          {
6191             rlcConfig->choice.am = NULLP;
6192             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6193             if(!rlcConfig->choice.am)
6194             {
6195                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6196                return RFAILED;
6197             }
6198
6199             /* UL */
6200             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
6201             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6202             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
6203             {
6204                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6205                return RFAILED;
6206             }
6207             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
6208             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
6209             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
6210             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
6211             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
6212
6213             /* DL */
6214             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
6215             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6216             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
6217             {
6218                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6219                return RFAILED;
6220             }
6221             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
6222             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
6223             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
6224
6225             break;
6226          }
6227
6228       case RLC_Config_PR_um_Bi_Directional:
6229          {
6230             rlcConfig->choice.um_Bi_Directional = NULLP;
6231             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
6232             if(!rlcConfig->choice.um_Bi_Directional)
6233             {
6234                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6235                return RFAILED;
6236             }
6237
6238             /* UL */
6239             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
6240             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6241             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
6242             {
6243                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6244                return RFAILED;
6245             }
6246             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
6247
6248             /* DL */
6249             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
6250             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6251             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
6252             {
6253                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6254                return RFAILED;
6255             }
6256             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
6257             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
6258             break;
6259          }
6260    }
6261    return ROK;
6262 }
6263
6264 /*******************************************************************
6265  *
6266  * @brief Builds MAC LC Config
6267  *
6268  * @details
6269  *
6270  *    Function : BuildMacLCConfig
6271  *
6272  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
6273  *
6274  * @params[in] struct LogicalChannelConfig macLcConfig
6275  *
6276  * @return ROK     - success
6277  *         RFAILED - failure
6278  *
6279  * ****************************************************************/
6280 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6281 {
6282
6283    macLcConfig->ul_SpecificParameters = NULLP;
6284    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6285    if(!macLcConfig->ul_SpecificParameters)
6286    {
6287       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6288       return RFAILED;
6289    }
6290
6291    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6292    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6293    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6294    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6295    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6296    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6297    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6298
6299    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6300    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6301    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6302    {
6303       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6304       return RFAILED;
6305    }
6306    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6307
6308    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6309    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6310    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6311    {
6312       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6313       return RFAILED;
6314    }
6315    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6316
6317    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6318    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6319    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6320
6321    return ROK;
6322 }
6323 /*******************************************************************
6324  *
6325  * @brief Builds RLC Bearer to Add/Mod list
6326  *
6327  * @details
6328  *
6329  *    Function :BuildRlcBearerToAddModList
6330  *
6331  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6332  *
6333  * @params[in] rlc_BearerToAddModList
6334  *
6335  * @return ROK     - success
6336  *         RFAILED - failure
6337  *
6338  * ****************************************************************/
6339 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6340 {
6341    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6342
6343    if(updateAllRbCfg)
6344       elementCnt = ueCb->numSrb + ueCb->numDrb;
6345    else
6346    {
6347       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6348       {
6349          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6350             elementCnt++;
6351       }
6352
6353       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6354       {
6355          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6356             elementCnt++;
6357       }
6358    }
6359
6360    if(!elementCnt)
6361    {
6362       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6363       return ROK;
6364    }
6365    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6366    if(!rlcBearerList)
6367    {
6368       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6369       return RFAILED;
6370    }
6371    rlcBearerList->list.count = elementCnt;
6372    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6373
6374    rlcBearerList->list.array = NULLP;
6375    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6376    if(!rlcBearerList->list.array)
6377    {
6378       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6379       return RFAILED;
6380    }
6381
6382    for(idx=0; idx<rlcBearerList->list.count; idx++)
6383    {
6384       rlcBearerList->list.array[idx] = NULLP;
6385       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6386       if(!rlcBearerList->list.array[idx])
6387       {
6388          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6389          return RFAILED;
6390       }
6391    }
6392
6393    idx = 0;
6394
6395    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6396    {
6397       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6398          continue;
6399
6400       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6401
6402       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6403       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6404       {
6405          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6406          return RFAILED;
6407       }
6408
6409       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6410       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6411
6412       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6413       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6414       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6415       if(!rlcBearerList->list.array[idx]->rlc_Config)
6416       {
6417          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6418          return RFAILED;
6419       }
6420
6421       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6422       {
6423          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6424          return RFAILED;
6425       }
6426
6427       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6428       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6429       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6430       {
6431          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6432          return RFAILED;
6433       }
6434
6435       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6436       {
6437          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6438          return RFAILED;
6439       }
6440       idx++;
6441    }
6442
6443    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6444    {
6445       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6446          continue;
6447
6448       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6449
6450       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6451       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6452       {
6453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6454          return RFAILED;
6455       }
6456
6457       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6458       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6459
6460       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6461       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6462       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6463       if(!rlcBearerList->list.array[idx]->rlc_Config)
6464       {
6465          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6466          return RFAILED;
6467       }
6468
6469       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6470       {
6471          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6472          return RFAILED;
6473       }
6474
6475       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6476       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6477       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6478       {
6479          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6480          return RFAILED;
6481       }
6482
6483       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6484       {
6485          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6486          return RFAILED;
6487       }
6488       idx++;
6489    }
6490    return ROK;
6491 }
6492
6493 /*******************************************************************
6494  *
6495  * @brief Free memory allocated for CellGroupConfig
6496  *
6497  * @details
6498  *
6499  *    Function : FreeMemCellGrpCfg
6500  *
6501  *    Functionality: Deallocating memory of CellGroupConfig
6502  *
6503  * @params[in] pointer to CellGroupConfigRrc_t
6504  *
6505  * @return ROK     - success
6506  *         RFAILED - failure
6507  *
6508  ******************************************************************/
6509 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6510 {
6511    uint8_t idx=0;
6512    SpCellConfig_t *spCellCfg=NULLP;
6513    ServingCellConfig_t *srvCellCfg=NULLP;
6514    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6515    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6516    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6517    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6518    struct RLC_Config *rlcConfig=NULLP;
6519    struct LogicalChannelConfig *macLcConfig=NULLP;
6520    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6521    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6522    struct TAG_Config *tagConfig=NULLP;
6523    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6524    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6525    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6526
6527    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6528    if(rlcBearerList)
6529    {
6530       if(rlcBearerList->list.array)
6531       {
6532          for(idx=0; idx<rlcBearerList->list.count; idx++)
6533          {
6534             if(rlcBearerList->list.array[idx])
6535             {
6536                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6537                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6538                if(rlcConfig)
6539                {
6540                   if(rlcConfig->choice.am)
6541                   {
6542                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6543                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6544                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6545                   }
6546                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6547                }
6548                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6549                if(macLcConfig)
6550                {
6551                   if(macLcConfig->ul_SpecificParameters)
6552                   {
6553                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6554                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6555                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6556                   }
6557                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6558                }
6559                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6560             }
6561          }
6562          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6563       }
6564       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6565    }
6566
6567    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6568    if(macCellGrpCfg)
6569    {
6570       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6571       if(schedulingRequestConfig)
6572       {
6573          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6574          if(schReqList)
6575          {
6576             if(schReqList->list.array)
6577             {
6578                for(idx=0;idx<schReqList->list.count; idx++)
6579                {
6580                   if(schReqList->list.array[idx])
6581                   {
6582                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6583                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6584                   }
6585                }
6586                CU_FREE(schReqList->list.array, schReqList->list.size);
6587             }
6588             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6589                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6590             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6591       }
6592       if(macCellGrpCfg->bsr_Config)
6593       {
6594          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6595       }
6596       tagConfig = macCellGrpCfg->tag_Config;
6597       if(tagConfig)
6598       {
6599          tagList = tagConfig->tag_ToAddModList;
6600          if(tagList)
6601          {
6602             if(tagList->list.array)
6603             {
6604                for(idx=0; idx<tagList->list.count; idx++)
6605                {
6606                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6607                }
6608                CU_FREE(tagList->list.array, tagList->list.size);
6609             }
6610             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6611          }
6612          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6613       }
6614
6615       phrConfig = macCellGrpCfg->phr_Config;
6616       if(phrConfig)
6617       {
6618          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6619          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6620       }
6621
6622       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6623    }
6624
6625    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6626    if(phyCellGrpCfg)
6627    {
6628       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6629       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6630    }
6631
6632    spCellCfg = cellGrpCfg->spCellConfig;
6633    if(spCellCfg)
6634    {
6635       if(spCellCfg->servCellIndex)
6636       {
6637          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6638          {
6639             if(spCellCfg->spCellConfigDedicated)
6640             {
6641                srvCellCfg = spCellCfg->spCellConfigDedicated;
6642                if(srvCellCfg->initialDownlinkBWP)
6643                {
6644                   dlBwp = srvCellCfg->initialDownlinkBWP;
6645                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6646                   {
6647                      if(srvCellCfg->defaultDownlinkBWP_Id)
6648                      {
6649                         if(srvCellCfg->uplinkConfig)
6650                         {
6651                            if(srvCellCfg->pdsch_ServingCellConfig)
6652                            {
6653                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6654                               if(pdschCfg->choice.setup)
6655                               {
6656                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6657                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6658                               }
6659                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6660                                        ServingCellConfig__pdsch_ServingCellConfig));
6661                            }
6662                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6663                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6664                         }
6665                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6666                      }
6667                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6668                   }
6669                   if(dlBwp->pdcch_Config)
6670                   {
6671                      if(dlBwp->pdsch_Config)
6672                      {
6673                         FreeBWPDlDedPdschCfg(dlBwp);
6674                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6675                      }
6676                      FreeBWPDlDedPdcchCfg(dlBwp);
6677                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6678                   }
6679                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6680                }
6681                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6682             }
6683             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6684          }
6685          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6686       }
6687       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6688    }
6689    return ROK;
6690 }
6691
6692 /*******************************************************************
6693  *
6694  * @brief Fills CellGroupConfig
6695  *
6696  * @details
6697  *
6698  *    Function : fillCellGrpCfg
6699  *
6700  *    Functionality: Fills CellGroupConfig
6701  *
6702  * @params[in] pointer to CellGroupConfigRrc_t
6703  *
6704  * @return ROK     - success
6705  *         RFAILED - failure
6706  *
6707  ******************************************************************/
6708
6709 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6710 {
6711    uint8_t               ret = RFAILED;
6712    CellGroupConfigRrc_t  cellGrpCfg;
6713    asn_enc_rval_t        encRetVal;
6714
6715    while(true)
6716    {
6717       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6718
6719       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6720
6721       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6722       {
6723          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6724          break;
6725       }
6726
6727       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6728       cellGrpCfg.mac_CellGroupConfig = NULLP;
6729       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6730       if(!cellGrpCfg.mac_CellGroupConfig)
6731       {
6732          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6733          break;
6734       }
6735       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6736       {
6737          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6738          break;
6739       }
6740
6741       cellGrpCfg.physicalCellGroupConfig = NULLP;
6742       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6743       if(!cellGrpCfg.physicalCellGroupConfig)
6744       {
6745          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6746          break;
6747       }
6748       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6749       {
6750          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6751          break;
6752       }
6753
6754       cellGrpCfg.spCellConfig = NULLP;
6755       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6756       if(!cellGrpCfg.spCellConfig)
6757       {
6758          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6759          break;
6760       }
6761       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6762       {
6763          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6764          break;
6765       }
6766
6767       cellGrpCfg.sCellToAddModList = NULLP;
6768       cellGrpCfg.sCellToReleaseList = NULLP;
6769       cellGrpCfg.ext1 = NULLP;
6770
6771       /* encode cellGrpCfg into duToCuRrcContainer */
6772       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6773       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6774       encBufSize = 0;
6775       encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6776       /* Encode results */
6777       if(encRetVal.encoded == ENCODE_FAIL)
6778       {
6779          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6780                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6781          break;
6782       }
6783       else
6784       {
6785          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6786          for(int i=0; i< encBufSize; i++)
6787          {
6788             DU_LOG("%x",encBuf[i]);
6789          }
6790       }
6791
6792       cellGrp->size = encBufSize;
6793       CU_ALLOC(cellGrp->buf, cellGrp->size);
6794       if(!cellGrp->buf)
6795       {
6796          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6797          break;
6798       }
6799       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6800       ret = ROK;
6801       break;
6802    }
6803    FreeMemCellGrpCfg(&cellGrpCfg);
6804    return ret;
6805 }
6806
6807 /*******************************************************************
6808  *
6809  * @brief Free UE Capability RAT container
6810  *
6811  * @details
6812  *
6813  *    Function : freeUeCapRatCont
6814  *
6815  *    Functionality:
6816  *       Free UE Capability RAT conatiner
6817  *
6818  * @params[in]
6819  * @return ROK     - success
6820  *         RFAILED - failure
6821  *
6822  * ****************************************************************/
6823 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6824 {
6825    uint8_t idx;
6826    FeatureSets_t *featureSets;
6827
6828    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6829    {
6830       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6831       {
6832          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6833             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6834       }
6835       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6836    }
6837
6838    if(ueNrCap->featureSets)
6839    {
6840       featureSets = ueNrCap->featureSets;
6841       if(featureSets->featureSetsDownlinkPerCC)
6842       {
6843          if(featureSets->featureSetsDownlinkPerCC->list.array)
6844          {
6845             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6846             {
6847                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6848                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6849                         sizeof(ModulationOrder_t));
6850                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6851             }
6852             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6853          }
6854          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6855       }
6856
6857       if(featureSets->featureSetsUplinkPerCC)
6858       {
6859          if(featureSets->featureSetsUplinkPerCC->list.array)
6860          {
6861             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6862             {
6863                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6864                {
6865                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6866                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6867                          sizeof(ModulationOrder_t));
6868                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6869                }
6870             }
6871             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6872          }
6873          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6874       }
6875       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6876    }
6877 }
6878
6879 /*******************************************************************
6880  *
6881  * @brief Free UE capability RAT container list
6882  *
6883  * @details
6884  *
6885  *    Function : freeUeCapRatContList
6886  *
6887  *    Functionality: Free UE capability RAT container list
6888  *
6889  * @params[in]
6890  * @return ROK     - success
6891  *         RFAILED - failure
6892  *
6893  * ****************************************************************/
6894 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6895 {
6896    uint8_t idx;
6897    if(ueCapablityList->list.array)
6898    {
6899       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6900       {
6901          if(ueCapablityList->list.array[idx])
6902             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6903       }
6904       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6905    }
6906 }
6907
6908 /*******************************************************************
6909  *
6910  * @brief Free Handover preparation information
6911  *
6912  * @details
6913  *
6914  *    Function : freeHOPreparationInfo
6915  *
6916  *    Functionality: Free Handover preparation information
6917  *
6918  * @params[in]
6919  * @return ROK     - success
6920  *         RFAILED - failure
6921  *
6922  * ****************************************************************/
6923 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6924 {
6925    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6926
6927    if(hoPrep->criticalExtensions.choice.c1)
6928    {
6929       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6930       {
6931          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6932          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6933          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6934                sizeof(HandoverPreparationInformationRrc_IEs_t));
6935       }
6936       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6937    }
6938 }
6939
6940 /*******************************************************************
6941  *
6942  * @brief Fill feature sets
6943  *
6944  * @details
6945  *
6946  *    Function : fillFeatureSets
6947  *
6948  *    Functionality: Fill feature sets
6949  *
6950  * @params[in]
6951  * @return ROK     - success
6952  *         RFAILED - failure
6953  *
6954  * ****************************************************************/
6955 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6956 {
6957    uint8_t idx, elementCnt;
6958
6959    featureSets->featureSetsDownlink = NULLP;
6960    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6961    if(!featureSets->featureSetsDownlinkPerCC)
6962    {
6963       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6964       return RFAILED;
6965    }
6966
6967    elementCnt = 1;
6968    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6969    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6970    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6971    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6972    {
6973       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6974       return RFAILED;
6975    }
6976
6977    for(idx = 0; idx < elementCnt; idx++)
6978    {
6979       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6980       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6981       {
6982          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6983          return RFAILED;
6984       }
6985    }
6986
6987    idx = 0;
6988    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6989    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6990    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6991    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6992    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6993
6994    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6995    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6996    {
6997       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6998       return RFAILED;
6999    }
7000    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
7001
7002    featureSets->featureSetsUplink = NULLP;
7003    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
7004    if(!featureSets->featureSetsUplinkPerCC)
7005    {
7006       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7007       return RFAILED;
7008    }
7009
7010    elementCnt = 1;
7011    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
7012    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
7013    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
7014    if(!featureSets->featureSetsUplinkPerCC->list.array)
7015    {
7016       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7017       return RFAILED;
7018    }
7019
7020    for(idx = 0; idx < elementCnt; idx++)
7021    {
7022       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
7023       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
7024       {
7025          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7026          return RFAILED;
7027       }
7028    }
7029
7030    idx = 0;
7031    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
7032    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
7033    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
7034    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
7035    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
7036    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
7037
7038    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
7039    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
7040    {
7041       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7042       return RFAILED;
7043    }
7044    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
7045
7046    return ROK;
7047 }
7048
7049 /*******************************************************************
7050  *
7051  * @brief Fill UE capability RAT container
7052  *
7053  * @details
7054  *
7055  *    Function : fillUeCapRatCont
7056  *
7057  *    Functionality: Fill UE capability RAT container
7058  *
7059  * @params[in] UE Capability RAT container buffer
7060  * @return ROK     - success
7061  *         RFAILED - failure
7062  *
7063  * ****************************************************************/
7064 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
7065 {
7066    uint8_t             ret = ROK;
7067    uint8_t             idx, elementCnt;
7068    asn_enc_rval_t      encRetVal;
7069    UE_NR_Capability_t  ueNrCap;
7070
7071    while(true)
7072    {
7073       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
7074
7075       /* Filling PDCP parameters */
7076       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
7077       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
7078       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
7079       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
7080       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
7081       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
7082       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
7083       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
7084       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
7085       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
7086       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
7087       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
7088       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
7089       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
7090       ueNrCap.pdcp_Parameters.shortSN = NULLP;
7091       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
7092       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
7093
7094       ueNrCap.rlc_Parameters = NULLP;
7095       ueNrCap.mac_Parameters = NULLP;
7096
7097       /* Filling PHY parameters */
7098       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
7099       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
7100       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
7101       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
7102       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
7103
7104       /* Filling RF parameters */
7105       elementCnt = 1;
7106       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
7107       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
7108       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
7109       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
7110       {
7111          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
7112          ret = RFAILED;
7113          break;
7114       }
7115
7116       for(idx = 0; idx < elementCnt; idx++)
7117       {
7118          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
7119          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
7120          {
7121             ret = RFAILED;
7122             break;
7123          }
7124       }
7125       if(ret == RFAILED)
7126          break;
7127
7128       idx = 0;
7129       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
7130       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
7131       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
7132
7133       ueNrCap.measAndMobParameters = NULLP;
7134       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
7135       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
7136       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
7137       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
7138       ueNrCap.featureSets = NULLP;
7139
7140       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
7141       if(!ueNrCap.featureSets)
7142       {
7143          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
7144          ret = RFAILED;
7145          break;
7146       }
7147
7148       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
7149       {
7150          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
7151          ret = RFAILED;
7152          break;
7153       }
7154
7155       ueNrCap.featureSetCombinations = NULLP;
7156       ueNrCap.lateNonCriticalExtension = NULLP;
7157       ueNrCap.nonCriticalExtension = NULLP;
7158
7159       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7160       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
7161       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7162       encBufSize = 0;
7163       encRetVal = uper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
7164
7165       /* Encode results */
7166       if(encRetVal.encoded == ENCODE_FAIL)
7167       {
7168          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7169             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7170          break;
7171       }
7172       else
7173       {
7174          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7175          for(int i=0; i< encBufSize; i++)
7176          {
7177             DU_LOG("%x",encBuf[i]);
7178          }
7179       }
7180
7181       ueCapRatContBuf->size = encBufSize;
7182       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
7183       if(!ueCapRatContBuf->buf)
7184       {
7185          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7186          break;
7187       }
7188       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
7189       ret = ROK;
7190       break;
7191    }
7192    freeUeCapRatCont(&ueNrCap);
7193    return ROK;
7194 }
7195
7196 /*******************************************************************
7197  *
7198  * @brief Fill UE Capability RAT container list
7199  *
7200  * @details
7201  *
7202  *    Function : fillUeCapRatContList
7203  *
7204  *    Functionality: Fill UE Capability RAT container list
7205
7206  *
7207  * @params[in] UE capability RAT container list
7208  * @return ROK     - success
7209  *         RFAILED - failure
7210  *
7211  * ****************************************************************/
7212 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
7213 {
7214     uint8_t          ret = RFAILED;
7215     uint8_t          idx, elementCnt;
7216
7217     while(true)
7218     {
7219        elementCnt = 1;
7220        ueCapablityList->list.count = elementCnt;
7221        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
7222
7223        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
7224        if(!ueCapablityList->list.array)
7225        {
7226           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7227           ret = RFAILED;
7228           break;
7229        }
7230
7231        for(idx=0; idx<elementCnt; idx++)
7232        {
7233           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
7234           if(ueCapablityList->list.array[idx] == NULLP)
7235           {
7236              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7237              ret = RFAILED;
7238              break;
7239           }
7240        }
7241        idx = 0;
7242        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
7243        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
7244        {
7245           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
7246           ret = RFAILED;
7247           break;
7248        }
7249
7250        ret = ROK;
7251        break;
7252     }
7253     return ret;
7254 }
7255
7256 /*******************************************************************
7257  *
7258  * @brief Fill UE Capability RAT container list octet string
7259  *
7260  * @details
7261  *
7262  *    Function : fillUeCapRatContListBuf
7263  *
7264  *    Functionality: Fill UE Capability RAT container list octet string
7265
7266  *
7267  * @params[in] UE capability RAT container list buffer
7268  * @return ROK     - success
7269  *         RFAILED - failure
7270  *
7271  * ****************************************************************/
7272 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
7273 {
7274    uint8_t          ret = RFAILED;
7275    asn_enc_rval_t   encRetVal;
7276    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7277
7278    while(true)
7279    {
7280       ret = fillUeCapRatContList(&ueCapablityList);
7281       if(ret != ROK)
7282       {
7283          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7284          break;
7285       }
7286
7287       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7288       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7289       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7290       encBufSize = 0;
7291       encRetVal = uper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7292             &ueCapablityList, PrepFinalEncBuf, encBuf);
7293
7294       /* Encode results */
7295       if(encRetVal.encoded == ENCODE_FAIL)
7296       {
7297          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7298                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7299          break;
7300       }
7301       else
7302       {
7303          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7304          for(int i=0; i< encBufSize; i++)
7305          {
7306             DU_LOG("%x",encBuf[i]);
7307          }
7308       }
7309
7310       ueCapablityListBuf->size = encBufSize;
7311       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7312       if(!ueCapablityListBuf->buf)
7313       {
7314          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7315          break;
7316       }
7317       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7318       ret = ROK;
7319       break;
7320    }
7321    freeUeCapRatContList(&ueCapablityList);
7322    return ret;
7323 }
7324
7325 /*******************************************************************
7326  *
7327  * @brief Free Measurement Timing Configuration
7328  *
7329  * @details
7330  *
7331  *    Function : freeMeasuementTimingConfig
7332  *
7333  *    Functionality: Free Measurement Timing Configuration
7334  *
7335  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7336  * @return void
7337  *
7338  * ****************************************************************/
7339 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7340 {
7341    uint8_t measCfgIdx;
7342    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7343    MeasTiming_t *measTiming = NULLP;
7344
7345    if(measTimingConfig.criticalExtensions.choice.c1)
7346    {
7347       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7348       {
7349          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7350          if(measTimingCfg->measTiming)
7351          {
7352             if(measTimingCfg->measTiming->list.array)
7353             {
7354                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7355                {
7356                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7357                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7358                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7359                }
7360                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7361             }
7362             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7363          }
7364          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7365       }
7366       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7367    }
7368 }
7369
7370 /*******************************************************************
7371  *
7372  * @brief Fill Measurement Timing Configuration
7373  *
7374  * @details
7375  *
7376  *    Function : fillMeasTimingCfg
7377  *
7378  *    Functionality: Fill Measurement Timing Configuration
7379  *
7380  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7381  * @return ROK     - success
7382  *         RFAILED - failure
7383  *
7384  * ****************************************************************/
7385 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7386 {
7387    uint8_t elementCnt = 0;
7388    uint8_t measCfgIdx = 0;
7389    MeasTiming_t *measTiming;
7390    SSB_MTC_t *smtc;
7391
7392    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7393    if(!measTimingCfg->measTiming)
7394    {
7395       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7396       return RFAILED;
7397    }
7398
7399    elementCnt = 1;
7400    measTimingCfg->measTiming->list.count = elementCnt;
7401    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7402    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7403    if(!measTimingCfg->measTiming->list.array)
7404    {
7405       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7406       return RFAILED;
7407    }
7408
7409    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7410    {
7411       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7412       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7413       {
7414          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7415          return RFAILED;
7416       }
7417    }
7418
7419    measCfgIdx = 0;
7420    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7421    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7422    if(!measTiming->frequencyAndTiming)
7423    {
7424       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7425       return RFAILED;
7426    }
7427
7428    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7429    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7430
7431    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7432    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7433    smtc->periodicityAndOffset.choice.sf20 = 0;
7434    smtc->duration = SSB_MTC__duration_sf1;
7435    return ROK;
7436 }
7437
7438 /*******************************************************************
7439  *
7440  * @brief Fill Measurement Timing Configuration Octet string
7441  *
7442  * @details
7443  *
7444  *    Function : fillMeasConfigBuf
7445  *
7446  *    Functionality: Fill Measurement Timing Configuration Octet string
7447
7448  *
7449  * @params[in] MeasConfig_t *measConfgBuf
7450  * @return ROK     - success
7451  *         RFAILED - failure
7452  *
7453  * ****************************************************************/
7454 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7455 {
7456    uint8_t          ret = RFAILED;
7457    asn_enc_rval_t   encRetVal;
7458    MeasurementTimingConfigurationRrc_t measTimingConfig;
7459
7460    while(true)
7461    {
7462       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7463       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7464       if(!measTimingConfig.criticalExtensions.choice.c1)
7465       {
7466          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7467          return RFAILED;
7468       }
7469       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7470
7471       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7472       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7473       {
7474          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7475          return RFAILED;
7476       }
7477
7478       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7479       if(ret != ROK)
7480       {
7481          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7482          break;
7483       }
7484
7485       /* Encode measurement timing configuration into octet string */
7486       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7487       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7488       encBufSize = 0;
7489       encRetVal = uper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7490
7491       /* Encode results */
7492       if(encRetVal.encoded == ENCODE_FAIL)
7493       {
7494          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7495                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7496          break;
7497       }
7498       else
7499       {
7500          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7501          for(int i=0; i< encBufSize; i++)
7502          {
7503             DU_LOG("%x",encBuf[i]);
7504          }
7505       }
7506
7507       measTimingConfigBuf->size = encBufSize;
7508       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7509       if(!measTimingConfigBuf->buf)
7510       {
7511          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7512          break;
7513       }
7514       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7515       ret = ROK;
7516       break;
7517    }
7518    freeMeasuementTimingConfig(measTimingConfig);
7519    return ret;
7520 }
7521
7522 /******************************************************************
7523  *
7524  * @brief Free RRC reconfiguration non-critical extension
7525  *
7526  * @details
7527  *
7528  *    Function : freeRrcReconfigNonCriticalExt
7529  *
7530  *    Functionality: Free RRC reconfiguration non-critical extension
7531  *
7532  * @params[in] RRC reconfiguration IE
7533  * @return void
7534  *
7535  * ****************************************************************/
7536 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7537 {
7538    if(rrcRecfg->masterCellGroup)
7539    {
7540       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7541    }
7542 }
7543
7544 /******************************************************************
7545  *
7546  * @brief Free measurement object addmod list
7547  *
7548  * @details
7549  *
7550  *    Function : freeMeasObjToAddModList
7551  *
7552  *    Functionality: Free measurement object add mod list
7553  *
7554  * @params[in] Measurement object add/mod list
7555  * @return void
7556  *
7557  * ****************************************************************/
7558 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7559 {
7560    uint8_t objIdx;
7561    MeasObjectNR_t *measObject;
7562
7563    if(measObjList->list.array)
7564    {
7565       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7566       {
7567          if(measObjList->list.array[objIdx])
7568          {
7569             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7570             {
7571                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7572                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7573                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7574                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7575                if(measObject->absThreshSS_BlocksConsolidation)
7576                {
7577                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7578                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7579                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7580                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7581                }
7582                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7583                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7584                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7585                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7586                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7587             }
7588             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7589          }
7590       }
7591       CU_FREE(measObjList->list.array, measObjList->list.size);
7592    }
7593 }
7594
7595 /******************************************************************
7596  *
7597  * @brief Free report config add mod list
7598  *
7599  * @details
7600  *
7601  *    Function : freeReportCfgToAddModList
7602  *
7603  *    Functionality: Free report config add mod list
7604  *
7605  * @params[in] Report config list
7606  * @return void
7607  *
7608  * ****************************************************************/
7609 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7610 {
7611    uint8_t reportCfgIdx;
7612    ReportConfigToAddMod_t *reportCfg;
7613    ReportConfigNR_t *reportCfgNr;
7614    EventTriggerConfig_t *eventTriggCfg;
7615
7616    if(reportCfgList->list.array)
7617    {
7618       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7619       {
7620          if(reportCfgList->list.array[reportCfgIdx])
7621          {
7622             reportCfg = reportCfgList->list.array[reportCfgIdx];
7623             if(reportCfg->reportConfig.choice.reportConfigNR)
7624             {
7625                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7626                if(reportCfgNr->reportType.choice.eventTriggered)
7627                {
7628                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7629                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7630                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7631                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7632                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7633                }
7634             }
7635          }
7636          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7637       }
7638       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7639    }
7640 }
7641
7642 /******************************************************************
7643  *
7644  * @brief Free measurement id to add mod list
7645  *
7646  * @details
7647  *
7648  *    Function : freeMeasIdToAddModList
7649  *
7650  *    Functionality: Free measurement id to add mod list
7651  *
7652  * @params[in] Measurement id to add mod list
7653  * @return void
7654  *
7655  * ****************************************************************/
7656 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7657 {
7658    uint8_t measIdIdx;
7659    if(measIdList->list.array)
7660    {
7661       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7662       {
7663          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7664       }
7665       CU_FREE(measIdList->list.array, measIdList->list.size);
7666    }
7667 }
7668
7669 /*******************************************************************
7670  *
7671  * @brief Free quantity config
7672  *
7673  * @details
7674  *
7675  *    Function : freeQunatityConfig
7676  *
7677  *    Functionality: Free quantity config
7678  *
7679  * @params[in] Quantity Config
7680  * @return void
7681  *
7682  * ****************************************************************/
7683 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7684 {
7685    uint8_t quanCfgIdx;
7686    QuantityConfigNR_t *quantityCfgNr;
7687
7688    if(quantityCfg->quantityConfigNR_List)
7689    {
7690       if(quantityCfg->quantityConfigNR_List->list.array)
7691       {
7692          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7693          {
7694             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7695             {
7696                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7697                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7698                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7699                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7700                if(quantityCfgNr->quantityConfigRS_Index)
7701                {
7702                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7703                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7704                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7705                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7706                }
7707                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7708             }
7709          }
7710          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7711       }
7712       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7713    }
7714 }
7715
7716 /******************************************************************
7717  *
7718  * @brief Free measurement Config
7719  *
7720  * @details
7721  *
7722  *    Function : freeMeasConfig
7723  *
7724  *    Functionality: Free measurement config
7725  *
7726  * @params[in] Measurement config
7727  * @return void
7728  *
7729  * ****************************************************************/
7730 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7731 {
7732    if(measConfig->measObjectToAddModList)
7733    {
7734       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7735       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7736    }
7737    if(measConfig->reportConfigToAddModList)
7738    {
7739       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7740       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7741    }
7742    if(measConfig->measIdToAddModList)
7743    {
7744       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7745       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7746    }
7747    if(measConfig->s_MeasureConfig)
7748    {
7749       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7750    }
7751    if(measConfig->quantityConfig)
7752    {
7753       freeQuantityConfig(measConfig->quantityConfig);
7754       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7755    }
7756 }
7757 /******************************************************************
7758  *
7759  * @brief Free DRB to AddMod List
7760  *
7761  * @details
7762  *
7763  *    Function : freeDrbToAddModList
7764  *
7765  *    Functionality: Free SRB to AddMod List
7766  *
7767  * @params[in] SBR to add/mod list
7768  * @return void
7769  *
7770  * ****************************************************************/
7771 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7772 {
7773    uint8_t drbIdx;
7774    if(drbToAddList->list.array)
7775    {
7776       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7777       {
7778          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7779          {
7780             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7781             {
7782                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7783                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7784                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7785                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7786             }
7787             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7788             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7789          }
7790          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7791       }
7792       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7793    }
7794 }
7795
7796 /******************************************************************
7797  *
7798  * @brief Free SRB to AddMod List
7799  *
7800  * @details
7801  *
7802  *    Function : freeSrbToAddModList
7803  *
7804  *    Functionality: Free SRB to AddMod List
7805  *
7806  * @params[in] SBR to add/mod list
7807  * @return void
7808  *
7809  * ****************************************************************/
7810 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7811 {
7812    uint8_t srbIdx;
7813    if(srbToAddList->list.array)
7814    {
7815       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7816       {
7817          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7818          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7819          {
7820             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7821             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7822          }
7823
7824          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7825       }
7826       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7827    }
7828 }
7829
7830 /******************************************************************
7831  *
7832  * @brief Free Radio Bearer Config
7833  *
7834  * @details
7835  *
7836  *    Function : freeRadioBearerConfig
7837  *
7838  *    Functionality: Free Radio Bearer config
7839  *
7840  * @params[in] Radio bearer config
7841  * @return void
7842  *
7843  * ****************************************************************/
7844 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7845 {
7846    if(radioBearerConfig->srb_ToAddModList)
7847    {
7848       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7849       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7850    }
7851    if(radioBearerConfig->drb_ToAddModList)
7852    {
7853       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7854       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7855    }
7856 }
7857
7858 /******************************************************************
7859  *
7860  * @brief Free reconfiguration message
7861  *
7862  * @details
7863  *
7864  *    Function : freeRrcReconfig
7865  *
7866  *    Functionality: Free reconfiguration message
7867  *
7868  * @params[in] RRC Reconfiguration message
7869  * @return void
7870  *
7871  * ****************************************************************/
7872 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7873 {
7874    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7875    {
7876       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7877       {
7878          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7879          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7880       }
7881       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7882       {
7883          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7884          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7885       }
7886       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7887       {
7888          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7889          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7890       }
7891       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7892    }
7893 }
7894
7895 /******************************************************************
7896  *
7897  * @brief Fill SRB To Add Mod list
7898  *
7899  * @details
7900  *
7901  *    Function : fillSrbToAddModList
7902  *
7903  *    Functionality: fill SRB to Add Mod list
7904  *
7905  * @params[in] UE control block
7906  *             SRB to Add/Mod list
7907  * @return ROK     - success
7908  *         RFAILED - failure
7909  *
7910  * ****************************************************************/
7911 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7912 {
7913    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7914
7915    if(updateAllRbCfg)
7916       elementCnt = ueCb->numSrb;
7917    else
7918    {
7919       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7920       {
7921          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7922             elementCnt++;
7923       }
7924    }
7925
7926    if(!elementCnt)
7927    {
7928       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7929       return ROK;
7930    }
7931
7932    srbToAddList->list.count = elementCnt;
7933    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7934
7935    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7936    if(!srbToAddList->list.array)
7937    {
7938       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7939       return RFAILED;
7940    }
7941
7942    srbIdx = 0;
7943    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7944    {
7945       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7946          continue;
7947
7948       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7949       if(!srbToAddList->list.array[srbIdx])
7950       {
7951          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7952          return RFAILED;
7953       }
7954
7955       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7956
7957       /* Reestablish PDCP */
7958       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7959       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7960       {
7961          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7962          return RFAILED;
7963       }
7964       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7965
7966       /* PDCP configuration */
7967       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7968       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7969       {
7970          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7971          return RFAILED;
7972       }
7973
7974       /* Reordering timer */
7975       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7976       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7977       {
7978          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7979          return RFAILED;
7980       }
7981       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7982
7983       srbIdx++;
7984    }
7985    return ROK;
7986 }
7987
7988 /******************************************************************
7989  *
7990  * @biief Fill DRBeTo Add Mod list
7991  *
7992  * @details
7993  *
7994  *    Function : fillDrbToAddModList
7995  *
7996  *    Functionality: fill DRB to Add Mod list
7997  *
7998  * @params[in] UE control block
7999  *             DRB to Add/Mod list
8000  * @return ROK     - success
8001  *         RFAILED - failure
8002  *
8003  * ****************************************************************/
8004 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
8005 {
8006    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
8007
8008    if(updateAllRbCfg)
8009       elementCnt = ueCb->numDrb;
8010    else
8011    {
8012       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
8013       {
8014          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
8015             elementCnt++;
8016       }
8017    }
8018
8019    if(!elementCnt)
8020    {
8021       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
8022       return ROK;
8023    }
8024
8025
8026    drbToAddList->list.count = elementCnt;
8027    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
8028
8029    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
8030    if(!drbToAddList->list.array)
8031    {
8032       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
8033       return RFAILED;
8034    }
8035
8036    drbIdx = 0;
8037    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
8038    {
8039       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
8040          continue;
8041
8042       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
8043       if(!drbToAddList->list.array[drbIdx])
8044       {
8045          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
8046          return RFAILED;
8047       }
8048
8049       /* DRB Id */
8050       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
8051
8052       /* PDCP Config */
8053       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
8054       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
8055       {
8056          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
8057          return RFAILED;
8058       }
8059
8060       /* PDCP Config -> DRB */
8061       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
8062       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
8063       {
8064          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
8065          return RFAILED;
8066       }
8067
8068       /* DRB -> Discard Timer */
8069       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
8070       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
8071       {
8072          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
8073          return RFAILED;
8074       }
8075       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
8076
8077       /* UL PDCP SN length */
8078       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
8079       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
8080       {
8081          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
8082          return RFAILED;
8083       }
8084       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
8085
8086       /* DL PDCP SN length */
8087       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
8088       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
8089       {
8090          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
8091          return RFAILED;
8092       }
8093       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
8094
8095       /* Header Compression */
8096       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
8097        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
8098
8099       /* Reordering timer */
8100       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
8101       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
8102       {
8103          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
8104          return RFAILED;
8105       }
8106       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
8107
8108       drbIdx++;
8109    }
8110
8111    return ROK;
8112 }
8113
8114 /******************************************************************
8115  *
8116  * @brief Fill Radio bearer configuration
8117  *
8118  * @details
8119  *
8120  *    Function : fillRadioBearerConfig
8121  *
8122  *    Functionality: Fill Radio bearer configuration
8123  *
8124  * @params[in] UE control block
8125  *             Radio bearer config pointer
8126  * @return ROK     - success
8127  *         RFAILED - failure
8128  *
8129  * ****************************************************************/
8130 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
8131 {
8132    /* SRB To Add/Mod List */
8133    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
8134    if(!radioBearerConfig->srb_ToAddModList)
8135    {
8136       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
8137       return RFAILED;
8138    }
8139    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
8140    {
8141       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
8142       return RFAILED;
8143    }
8144
8145    /* DRB To Add/Mod List */
8146    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
8147    if(!radioBearerConfig->drb_ToAddModList)
8148    {
8149       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
8150       return RFAILED;
8151     }
8152    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
8153    {
8154       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
8155       return RFAILED;
8156    }
8157
8158    return ROK;
8159 }
8160
8161 /*******************************************************************
8162  *
8163  * @brief Fill measurement object to add/mod list
8164  *
8165  * @details
8166  *
8167  *    Function : fillMeasObjToAddModList
8168  *
8169  *    Functionality: Fill measurement object to add/mod list
8170  *
8171  * @params[in] Measurement object to add/mod list
8172  * @return ROK     - success
8173  *         RFAILED - failure
8174  *
8175  * ****************************************************************/
8176 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
8177 {
8178    uint8_t elementCnt, objIdx;
8179    MeasObjectNR_t *measObject;
8180
8181    elementCnt = 1;
8182    measObjList->list.count = elementCnt;
8183    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
8184
8185    CU_ALLOC(measObjList->list.array, measObjList->list.size);
8186    if(!measObjList->list.array)
8187    {
8188       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
8189       return RFAILED;
8190    }
8191
8192    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
8193    {
8194       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
8195       if(!measObjList->list.array[objIdx])
8196       {
8197          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
8198          return RFAILED;
8199       }
8200    }
8201
8202    objIdx = 0;
8203    measObjList->list.array[objIdx]->measObjectId = 1;
8204    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
8205    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
8206    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
8207    {
8208       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
8209       return RFAILED;
8210    }
8211
8212    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
8213
8214    /* SSB frequency */
8215    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
8216    if(!measObject->ssbFrequency)
8217    {
8218       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
8219       return RFAILED;
8220    }
8221    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
8222
8223    /* Subcarrier spacing */
8224    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8225    if(!measObject->ssbSubcarrierSpacing)
8226    {
8227       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
8228       return RFAILED;
8229    }
8230    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
8231
8232    /* SMTC1 */
8233    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
8234    if(!measObject->smtc1)
8235    {
8236       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
8237       return RFAILED;
8238    }
8239    measObject->smtc1->duration = SSB_MTC__duration_sf1;
8240    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
8241    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
8242
8243    /* Absoulute threshold SSB consolidation */
8244    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
8245    if(!measObject->absThreshSS_BlocksConsolidation)
8246    {
8247       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
8248       return RFAILED;
8249    }
8250
8251    /* RSRP threshold */
8252    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
8253    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
8254    {
8255       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
8256       return RFAILED;
8257    }
8258    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
8259
8260    /* RSRQ threshold */
8261    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
8262    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
8263    {
8264       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
8265       return RFAILED;
8266    }
8267    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
8268
8269    /* SINR threshold */
8270    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
8271    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
8272    {
8273       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
8274       return RFAILED;
8275    }
8276    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8277
8278    /* Number of SSBs to average */
8279    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8280    if(!measObject->nrofSS_BlocksToAverage)
8281    {
8282       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8283       return RFAILED;
8284    }
8285    *(measObject->nrofSS_BlocksToAverage) = 2;
8286
8287    /* Quantity Config index */
8288    measObject->quantityConfigIndex = 1;
8289
8290    /* Offset MO */
8291    /* RSRP offset for SSB */
8292    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8293    if(!measObject->offsetMO.rsrpOffsetSSB)
8294    {
8295       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8296       return RFAILED;
8297    }
8298    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8299
8300    /* RSRQ offset for SSB */
8301    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8302    if(!measObject->offsetMO.rsrqOffsetSSB)
8303    {
8304       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8305       return RFAILED;
8306    }
8307    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8308
8309    /* SINR offset for SSB */
8310    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8311    if(!measObject->offsetMO.sinrOffsetSSB)
8312    {
8313       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8314       return RFAILED;
8315    }
8316    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8317
8318    return ROK;
8319 }
8320
8321 /*******************************************************************
8322  *
8323  * @brief Fill Report configuration to Add/mod list
8324  *
8325  * @details
8326  *
8327  *    Function : fillReportCfgToAddModList
8328  *
8329  *    Functionality: Fill Report configuration to Add/mod list
8330  *
8331  * @params[in] Report Config To Add/Mod List
8332  * @return ROK     - success
8333  *         RFAILED - failure
8334  *
8335  * ****************************************************************/
8336 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8337 {
8338    uint8_t elementCnt;
8339    uint8_t reportCfgIdx;
8340    ReportConfigToAddMod_t *reportCfg;
8341    ReportConfigNR_t *reportCfgNr;
8342    EventTriggerConfig_t *eventTriggCfg;
8343
8344    elementCnt = 1;
8345    reportCfgList->list.count = elementCnt;
8346    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8347
8348    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8349    if(!reportCfgList->list.array)
8350    {
8351       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8352       return RFAILED;
8353    }
8354
8355    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8356    {
8357       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8358       if(!reportCfgList->list.array[reportCfgIdx])
8359       {
8360          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8361          return RFAILED;
8362       }
8363    }
8364
8365    reportCfgIdx = 0;
8366    reportCfg = reportCfgList->list.array[reportCfgIdx];
8367    reportCfg->reportConfigId = 1;
8368    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8369
8370    /* Report Configuration for NR */
8371    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8372    if(!reportCfg->reportConfig.choice.reportConfigNR)
8373    {
8374       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8375       return RFAILED;
8376    }
8377    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8378
8379    /* Report Type */
8380    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8381    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8382    if(!reportCfgNr->reportType.choice.eventTriggered)
8383    {
8384       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8385       return RFAILED;
8386    }
8387    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8388
8389    /* Event 3 */
8390    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8391    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8392    if(!eventTriggCfg->eventId.choice.eventA3)
8393    {
8394       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8395       return RFAILED;
8396    }
8397
8398    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8399    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8400    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8401    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8402    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8403    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8404
8405    /* Reference Signal Type */
8406    eventTriggCfg->rsType = NR_RS_Type_ssb;
8407
8408    /* Report Interval */
8409    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8410
8411    /* Report Amount */
8412    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8413
8414    /* Report Quantity cell */
8415    eventTriggCfg->reportQuantityCell.rsrp = true;
8416    eventTriggCfg->reportQuantityCell.rsrq = false;
8417    eventTriggCfg->reportQuantityCell.sinr = false;
8418
8419    /* Maximum reported cells */
8420    eventTriggCfg->maxReportCells = 3;
8421
8422    /* Report qunatity RS Indexes */
8423    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8424    if(!eventTriggCfg->reportQuantityRS_Indexes)
8425    {
8426       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8427       return RFAILED;
8428    }
8429    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8430    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8431    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8432
8433    /* Maximum number of RS indexes to report */
8434    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8435    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8436    {
8437       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8438       return RFAILED;
8439    }
8440    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8441
8442    /* Include Beam measurement */
8443    eventTriggCfg->includeBeamMeasurements = false;
8444
8445    return ROK;
8446 }
8447
8448 /*******************************************************************
8449  *
8450  * @brief Fill measurement Id to add/mod list
8451
8452  * @details
8453  *
8454  *    Function : fillMeasIdToAddModList
8455  *
8456  *    Functionality: Fill measurement Id to add/mod list
8457  *
8458  * @params[in] Measurement Id to add/mod list
8459  * @return ROK     - success
8460  *         RFAILED - failure
8461  *
8462  * ****************************************************************/
8463 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8464 {
8465    uint8_t elementCnt;
8466    uint8_t measIdIdx;
8467
8468    elementCnt = 1;
8469    measIdList->list.count = elementCnt;
8470    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8471
8472    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8473    if(!measIdList->list.array)
8474    {
8475       return RFAILED;
8476    }
8477
8478    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8479    {
8480       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8481       if(!measIdList->list.array[measIdIdx])
8482       {
8483          return RFAILED;
8484       }
8485
8486       measIdIdx=0;
8487       measIdList->list.array[measIdIdx]->measId = 1;
8488       measIdList->list.array[measIdIdx]->measObjectId = 1;
8489       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8490    }
8491    return ROK;
8492 }
8493
8494 /*******************************************************************
8495  *
8496  * @brief Fill s-measurement configuration
8497  *
8498  * @details
8499  *
8500  *    Function : fillSMeasConfig
8501  *
8502  *    Functionality: Fill s-measurement configuration
8503  *
8504  * @params[in] s-Measurement config
8505  * @return ROK     - success
8506  *         RFAILED - failure
8507  *
8508  * ****************************************************************/
8509 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8510 {
8511    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8512    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8513
8514    return ROK;
8515 }
8516
8517 /*******************************************************************
8518  *
8519  * @brief Fill quantity config
8520  *
8521  * @details
8522  *
8523  *    Function : fillQunatityConfig
8524  *
8525  *    Functionality: Fill quantity config
8526  *
8527  * @params[in] Quantity Config
8528  * @return ROK     - success
8529  *         RFAILED - failure
8530  *
8531  * ****************************************************************/
8532 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8533 {
8534    uint8_t elementCnt = 0;
8535    uint8_t quanCfgIdx = 0;
8536    QuantityConfigNR_t *quantityCfgNr;
8537
8538    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8539    if(!quantityCfg->quantityConfigNR_List)
8540    {
8541       return RFAILED;
8542    }
8543
8544    elementCnt = 1;
8545    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8546    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8547
8548    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8549    if(!quantityCfg->quantityConfigNR_List->list.array)
8550    {
8551       return RFAILED;
8552    }
8553
8554    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8555    {
8556       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8557       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8558       {
8559          return RFAILED;
8560       }
8561    }
8562
8563    quanCfgIdx = 0;
8564    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8565
8566    /* Quantity Config of Reference signal */
8567    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8568    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8569    {
8570       return RFAILED;
8571    }
8572    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8573
8574    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8575    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8576    {
8577       return RFAILED;
8578    }
8579    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8580
8581    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8582    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8583    {
8584       return RFAILED;
8585    }
8586    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8587
8588    /* Quantity Config RS index */
8589    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8590    if(!quantityCfgNr->quantityConfigRS_Index)
8591    {
8592       return RFAILED;
8593    }
8594
8595    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8596    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8597    {
8598       return RFAILED;
8599    }
8600    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8601
8602    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8603    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8604    {
8605       return RFAILED;
8606    }
8607    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8608
8609    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8610    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8611    {
8612       return RFAILED;
8613    }
8614    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8615
8616    return ROK;
8617 }
8618
8619 /*******************************************************************
8620  *
8621  * @brief Fill measurement configuration
8622  *
8623  * @details
8624  *
8625  *    Function : fillMeasConfig
8626  *
8627  *    Functionality: Fill measurement configuration
8628  *
8629  * @params[in] Measurement config
8630  * @return ROK     - success
8631  *         RFAILED - failure
8632  *
8633  * ****************************************************************/
8634 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8635 {
8636    /* Measurement object to add/mod list */
8637    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8638    if(!measConfig->measObjectToAddModList)
8639    {
8640       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8641       return RFAILED;
8642    }
8643    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8644    {
8645       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8646       return RFAILED;
8647    }
8648
8649    /* Report Config To add/mod list */
8650    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8651    if(!measConfig->reportConfigToAddModList)
8652    {
8653       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8654       return RFAILED;
8655    }
8656    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8657    {
8658       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8659       return RFAILED;
8660    }
8661
8662    /* Measurement Id to add/mod list */
8663    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8664    if(!measConfig->measIdToAddModList)
8665    {
8666       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8667       return RFAILED;
8668    }
8669    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8670    {
8671       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8672       return RFAILED;
8673    }
8674
8675    /* S-Measurement config */
8676    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8677    if(!measConfig->s_MeasureConfig)
8678    {
8679       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8680       return RFAILED;
8681    }
8682    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8683    {
8684       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8685       return RFAILED;
8686    }
8687
8688    /* Qunatity Config */
8689    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8690    if(!measConfig->quantityConfig)
8691    {
8692       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8693       return RFAILED;
8694    }
8695    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8696    {
8697       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8698       return RFAILED;
8699    }
8700
8701 return ROK;
8702 }
8703
8704 /*******************************************************************
8705  *
8706  * @brief Fill RRC reconfiguration non-critical extension IE
8707  *
8708  * @details
8709  *
8710  *    Function : fillRrcReconfigNonCriticalExt
8711  *
8712  *    Functionality: Fill RRC reconfiguration non-critical extension
8713  *
8714  * @params[in] RRC Reconfig Non-critical extension
8715  * @return ROK     - success
8716  *         RFAILED - failure
8717  *
8718  * ****************************************************************/
8719 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8720 {
8721    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8722    if(!rrcRecfg->masterCellGroup)
8723    {
8724       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8725       return RFAILED;
8726    }
8727
8728    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8729    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8730    if(!rrcRecfg->masterCellGroup->buf)
8731    {
8732       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8733       return RFAILED;
8734    }
8735    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8736
8737 #if 0
8738    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8739     * received from DU */
8740    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8741    {
8742       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8743       return RFAILED;
8744    }
8745 #endif
8746
8747    return ROK;
8748 }
8749
8750 /*******************************************************************
8751  *
8752  * @brief Fill RRC reconfiguration structure
8753  *
8754  * @details
8755  *
8756  *    Function : fillRrcReconfig
8757  *
8758  *    Functionality: Fill RRC reconfiguration
8759
8760  *
8761  * @params[in] UE Cb
8762  *             RRC reconfiguration structure
8763  * @return ROK     - success
8764  *         RFAILED - failure
8765  *
8766  * ****************************************************************/
8767 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8768 {
8769    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8770
8771    rrcReconfig->rrc_TransactionIdentifier = 1;
8772    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8773
8774    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8775    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8776    {
8777       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8778       return RFAILED;
8779    }
8780
8781    /* Radio Bearer Configuration */
8782    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8783    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8784    {
8785       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8786       return RFAILED;
8787    }
8788    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8789    {
8790       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8791       return RFAILED;
8792    }
8793
8794    /* Measurement Configuration */
8795    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8796    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8797    {
8798       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8799       return RFAILED;
8800    }
8801    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8802    {
8803       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8804       return RFAILED;
8805    }
8806
8807    /* Non Critical extension */
8808    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8809    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8810    {
8811       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8812       return RFAILED;
8813    }
8814    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8815    {
8816       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8817       return RFAILED;
8818    }
8819    return ROK;
8820 }
8821
8822 /*******************************************************************
8823  *
8824  * @brief Fill RRC reconfiguration Octet string
8825  *
8826  * @details
8827  *
8828  *    Function : fillRrcReconfigBuf
8829  *
8830  *    Functionality: Fill RRC reconfiguration octet string
8831
8832  *
8833  * @params[in] OCTET_STRING_t buffer
8834  * @return ROK     - success
8835  *         RFAILED - failure
8836  *
8837  * ****************************************************************/
8838 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8839 {
8840    uint8_t          ret = RFAILED;
8841    asn_enc_rval_t   encRetVal;
8842    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8843    rrcReconfig = &rrcRecfg;
8844
8845    while(true)
8846    {
8847       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8848       {
8849          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8850          break;
8851       }
8852
8853       /* Encode RRC Reconfiguration */
8854       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8855       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8856       encBufSize = 0;
8857       encRetVal = uper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8858
8859       /* Encode results */
8860       if(encRetVal.encoded == ENCODE_FAIL)
8861       {
8862          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8863                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8864          break;
8865       }
8866       else
8867       {
8868          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8869          for(int i=0; i< encBufSize; i++)
8870          {
8871             DU_LOG("%x",encBuf[i]);
8872          }
8873       }
8874
8875       rrcReconfigBuf->size = encBufSize;
8876       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8877       if(!rrcReconfigBuf->buf)
8878       {
8879          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8880          break;
8881       }
8882       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8883       ret = ROK;
8884       break;
8885    }
8886
8887    freeRrcReconfig(rrcReconfig);
8888    return ret;
8889 }
8890
8891 /*******************************************************************
8892  *
8893  * @brief Fill HO preparation information Octet string
8894  *
8895  * @details
8896  *
8897  *    Function : fillHOPreparationInfoBuf
8898  *
8899  *    Functionality: Fill HO preparation information Octet string
8900
8901  *
8902  * @params[in] HandoverPreparationInformation_t buffer
8903  * @return ROK     - success
8904  *         RFAILED - failure
8905  *
8906  * ****************************************************************/
8907 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8908 {
8909    uint8_t          ret = RFAILED;
8910    asn_enc_rval_t   encRetVal;
8911    HandoverPreparationInformationRrc_t hoPrepInfo;
8912    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8913
8914    while(true)
8915    {
8916
8917       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8918       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8919       if(!hoPrepInfo.criticalExtensions.choice.c1)
8920       {
8921          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8922          break;
8923       }
8924       hoPrepInfo.criticalExtensions.choice.c1->present = \
8925          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8926
8927       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8928          sizeof(HandoverPreparationInformationRrc_IEs_t));
8929       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8930       {
8931          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8932          break;
8933       }
8934       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8935
8936       /* Fill UE Capability RAT container list */
8937       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8938       if(ret != ROK)
8939       {
8940          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8941          break;
8942       }
8943
8944       /* Fill Source config */
8945       hoPrepInfoIe->sourceConfig = NULLP;
8946       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8947       if(!hoPrepInfoIe->sourceConfig)
8948       {
8949          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8950          return RFAILED;
8951       }
8952       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8953
8954       if(ret != ROK)
8955       {
8956          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8957          return RFAILED;
8958       }
8959
8960       hoPrepInfoIe->rrm_Config = NULLP;
8961       hoPrepInfoIe->as_Context = NULLP;
8962       hoPrepInfoIe->nonCriticalExtension = NULLP;
8963
8964       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8965       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8966       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8967       encBufSize = 0;
8968       encRetVal = uper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8969             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8970
8971       /* Encode results */
8972       if(encRetVal.encoded == ENCODE_FAIL)
8973       {
8974          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8975                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8976          break;
8977       }
8978       else
8979       {
8980          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8981          for(int i=0; i< encBufSize; i++)
8982          {
8983             DU_LOG("%x",encBuf[i]);
8984          }
8985       }
8986
8987       hoPrepInfoBuf->size = encBufSize;
8988       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8989       if(!hoPrepInfoBuf->buf)
8990       {
8991          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8992          break;
8993       }
8994       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8995       ret = ROK;
8996       break;
8997    }
8998    freeHOPreparationInfo(&hoPrepInfo);
8999    return ret;
9000 }
9001
9002 /*******************************************************************
9003  *
9004  * @brief Fills CuToDuContainer
9005  *
9006  * @details
9007  *
9008  *    Function : fillCuToDuContainer
9009  *
9010  *    Functionality: Fills CuToDuContainer
9011  *
9012  * @params[in] pointer to CUtoDURRCInformation_t
9013  *
9014  * @return ROK     - success
9015  *         RFAILED - failure
9016  *
9017  ******************************************************************/
9018
9019 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
9020 {
9021    uint8_t elementCnt = 0;
9022    uint8_t ret = ROK;
9023    uint8_t idx;
9024
9025    /* UE Capabulity RAT Container List */
9026    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9027    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
9028    {
9029       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
9030       return RFAILED;
9031    }
9032    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
9033
9034 #if 0
9035
9036    /* Commenting this because:
9037     * CUToDURRCInformation->MeasConfig contains measurement gap configurations.
9038     * Howeever measurement gap is not supported in our code. Measurement Gap will
9039     * be required if we want to support inter-RAT handover or handover to
9040     * neighbouring cells operating on a different frequency than serving cell.
9041     *
9042     * In case we plan to use this IE in future, following fixes are required:
9043     * As of now, we are filling MeasurementTimingConfigurationRrc_t into rrcMsg->measConfig.
9044     * This is incorrect. We must fill MeasConfigRrc_t in rrcMsg->measConfig.
9045     * MeasurementTimingConfigurationRrc_t should be filled in
9046     * rrcMsg->iE_Extensions->MeasurementTimingConfiguration, if required.
9047     */
9048
9049    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
9050    if(!rrcMsg->measConfig)
9051    {
9052       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
9053       return RFAILED;
9054    }
9055    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
9056 #endif
9057
9058    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9059    {
9060       /* IE extensions */
9061       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9062       if(rrcMsg->iE_Extensions)
9063       {
9064          elementCnt = 1;
9065          rrcMsg->iE_Extensions->list.count = elementCnt;
9066          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
9067
9068          /* Initialize the CUtoDURRCInformation_ExtIEs */
9069          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9070
9071          if(rrcMsg->iE_Extensions->list.array == NULLP)
9072          {
9073             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
9074             ret = RFAILED;
9075          }
9076
9077          for(idx=0; idx<elementCnt; idx++)
9078          {
9079             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
9080             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
9081             {
9082                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
9083                ret = RFAILED;
9084             }
9085          }
9086
9087          idx = 0;
9088 #if 0
9089          /* Cell Group Configuration */
9090          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
9091          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9092          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
9093                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
9094          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
9095          idx++;
9096 #endif
9097          /* Handover Preparation Information */
9098          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
9099          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9100          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
9101                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
9102          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
9103       }
9104    }
9105    return ret;
9106 }
9107 /*******************************************************************
9108  *
9109  * @brief Build the drx cycle
9110  *
9111  * @details
9112  *
9113  *    Function : BuildDrxCycle
9114  *
9115  *    Functionality: Build drx cycle IE
9116  *
9117  * @params[in] pointer to DRXCycle_t
9118  *
9119  * @return ROK     - success
9120  *         RFAILED - failure
9121  *
9122  ******************************************************************/
9123 uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
9124 {
9125    drxCycle->longDRXCycleLength = LongDRXCycleLength_ms80;
9126    CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
9127    if(!drxCycle->shortDRXCycleLength)
9128    {
9129       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleLength");
9130       return RFAILED;
9131    }
9132    *(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
9133
9134    CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
9135    if(!drxCycle->shortDRXCycleTimer)
9136    {
9137       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleTimer");
9138       return RFAILED;
9139    }
9140    *(drxCycle->shortDRXCycleTimer) = 4;
9141    return ROK;
9142 }
9143 /*******************************************************************
9144  *
9145  * @brief Free CuToDuContainer
9146  *
9147  * @details
9148  *
9149  *    Function : FreeCuToDuInfo
9150  *
9151  *    Functionality: Free CuToDuContainer
9152  *
9153  * @params[in] pointer to CUtoDURRCInformation_t
9154  *
9155  * @return ROK     - success
9156  *         RFAILED - failure
9157  *
9158  ******************************************************************/
9159
9160 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9161 {
9162    uint8_t idx, idx2;
9163
9164    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9165    {
9166       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9167          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
9168       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9169    }
9170    if(rrcMsg->iE_Extensions)
9171    {
9172       if(rrcMsg->iE_Extensions->list.array)
9173       {
9174          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
9175          {
9176             if(rrcMsg->iE_Extensions->list.array[idx])
9177             {
9178                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
9179                {
9180                   case ProtocolIE_ID_id_CellGroupConfig:
9181                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9182                      {
9183                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
9184                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
9185
9186                      }
9187                      break;
9188                   default:
9189                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9190                            rrcMsg->iE_Extensions->list.array[idx]->id);
9191                      break;
9192                }
9193             }
9194             break;
9195          }
9196          for(idx2 = 0; idx2 < idx; idx2++)
9197          {
9198             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
9199          }
9200          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9201
9202       }
9203
9204       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9205    }
9206 }
9207 /*******************************************************************
9208  *
9209  * @brief Builds and sends the UE Setup Request
9210  *
9211  * @details
9212  *
9213  *    Function : BuildAndSendUeContextSetupReq
9214  *
9215  *    Functionality: Constructs the UE Setup Request and sends
9216  *                   it to the CU through SCTP.
9217  *
9218  * @params[in]
9219  *
9220  * @return ROK     - success
9221  *         RFAILED - failure
9222  *
9223  * ****************************************************************/
9224 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
9225 {
9226    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
9227    uint8_t   ret= RFAILED, ret1;
9228    uint8_t   elementCnt;
9229    uint8_t   idx, idx1, bufLen, duIdx;
9230    uint32_t  spCellId;
9231    DuDb      *targetDuDb = NULLP;
9232    F1AP_PDU_t           *f1apMsg = NULLP;
9233    UEContextSetupRequest_t *ueSetReq = NULLP;
9234    asn_enc_rval_t encRetVal;        /* Encoder return value */
9235    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9236
9237    while(true)
9238    {
9239       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
9240
9241       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9242       if(f1apMsg == NULLP)
9243       {
9244          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9245          break;
9246       }
9247
9248       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9249       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9250       if(f1apMsg->choice.initiatingMessage == NULLP)
9251       {
9252          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
9253          break;
9254       }
9255
9256       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
9257       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9258       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
9259
9260       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9261
9262       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9263          elementCnt = 7;
9264       else
9265       {
9266 #ifdef NR_DRX
9267          elementCnt = 12;
9268 #else
9269          elementCnt = 11;
9270 #endif
9271       }
9272       ueSetReq->protocolIEs.list.count = elementCnt;
9273       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
9274
9275       /* Initialize the UESetup members */
9276       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
9277
9278       if(ueSetReq->protocolIEs.list.array == NULLP)
9279       {
9280          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
9281          break;
9282       }
9283
9284       for(idx1=0; idx1<elementCnt; idx1++)
9285       {
9286          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
9287          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
9288          {
9289             break;
9290          }
9291       }
9292
9293       idx = 0;
9294
9295       /*GNB CU UE F1AP ID*/
9296       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9297       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9298       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
9299       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
9300
9301       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9302       {
9303          /*GNB DU UE F1AP ID*/
9304          idx++;
9305          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9306          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9307          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
9308          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
9309       }
9310
9311       /*Special Cell ID*/
9312       idx++;
9313       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
9314       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9315       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
9316       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9317       {
9318          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
9319          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
9320          /* Since we are supporting only one cell per DU, accessing 0th index to
9321           * get target cell info */
9322          spCellId = targetDuDb->cellCb[0].nrCellId;
9323       }
9324       else
9325          spCellId = ueCb->cellCb->nrCellId;
9326       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
9327       if(Nrcgiret != ROK)
9328       {
9329          break;
9330       }
9331
9332       /*Served Cell Index*/
9333       idx++;
9334       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9335       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9336       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9337       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9338
9339       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9340       {
9341          /*CellULConfigured*/
9342          idx++;
9343          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9344          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9345          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9346          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9347       }
9348
9349       /*CUtoDURRCContainer*/
9350       idx++;
9351       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9352       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9353       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9354       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9355       {
9356          break;
9357       }
9358
9359       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9360       {
9361          /*Drx cycle*/
9362 #ifdef NR_DRX
9363          idx++;
9364          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_DRXCycle;
9365          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9366          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
9367          if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
9368          {
9369             DU_LOG("\nERROR  -->  F1AP : Failed to build drx cycle");
9370             break;
9371          }
9372 #endif
9373          /*Special Cells to be SetupList*/
9374          idx++;
9375          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9376          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9377          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9378          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9379          if(SplCellListret != ROK)
9380          {
9381             break;
9382          }
9383       }
9384
9385       /*SRBs To Be Setup List*/
9386       idx++;
9387       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9388       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9389       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9390       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9391       if(SrbSetupret != ROK)
9392       {
9393          break;
9394       }
9395
9396       /*DRBs to Be Setup List*/
9397       idx++;
9398       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9399       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9400       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9401       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9402       if(ret1 != ROK)
9403       {
9404          break;
9405       }
9406
9407       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9408       {
9409          /* RRC delivery status request */
9410          idx++;
9411          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9412          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9413          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9414          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9415       }
9416
9417       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9418       idx++;
9419       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9420       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9421       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9422
9423       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9424       bufLen = 4;
9425       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9426       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9427             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9428       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9429       {
9430          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9431          break;
9432       }
9433       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9434       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9435
9436       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9437
9438       /* Encode the F1SetupRequest type as APER */
9439       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9440       encBufSize = 0;
9441       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9442
9443       /* Encode results */
9444       if(encRetVal.encoded == ENCODE_FAIL)
9445       {
9446          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9447                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9448          break;
9449       }
9450       else
9451       {
9452          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9453          for(int i=0; i< encBufSize; i++)
9454          {
9455             DU_LOG("%x",encBuf[i]);
9456          }
9457       }
9458
9459       /* Sending  msg  */
9460       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9461       {
9462          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9463          break;
9464       }
9465       ret = ROK;
9466       break;
9467    }
9468    FreeUeContextSetupReq(f1apMsg);
9469
9470    return ret;
9471 }/* End of BuildAndSendUeContextSetupReq*/
9472
9473 /**********************************************************************
9474  * @brief Function to extractTeId received in UE context setup Response
9475  *
9476  * @details
9477  *
9478  *    Function : extractTeId
9479  *
9480  *    Functionality:
9481  *         - Function to extract TeId
9482  *
9483  * @params[in]
9484  * @return ROK     - success
9485  *         RFAILED - failure
9486  *
9487  **********************************************************************/
9488 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9489 {
9490    uint8_t arrIdx = 0;
9491    uint32_t teId = 0;
9492    GTPTunnel_t *gtpDl = NULLP;
9493
9494    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9495    {
9496       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9497       {
9498          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9499          {
9500             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9501             if(gtpDl->gTP_TEID.size > 0)
9502             {
9503                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9504             }
9505             else
9506                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9507             return(teId);
9508          }
9509       }
9510    }
9511    return teId;
9512 }
9513
9514 /****************************************************************
9515  * @brief Function to add Drb tunnels
9516  *
9517  * @details
9518  *
9519  *    Function : addDrbTunnels
9520  *
9521  *    Functionality:
9522  *         - Function to add Drb tunnels
9523  *
9524  * @params[in]
9525  * @return ROK     - success
9526  *         RFAILED - failure
9527  *
9528  * ****************************************************************/
9529 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9530 {
9531    uint8_t ret = ROK;
9532    EgtpTnlEvt tnlEvt;
9533
9534    if(teId > MAX_TEID || teId < MIN_TEID)
9535    {
9536       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9537    }
9538    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9539    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9540    tnlEvt.lclTeid = teId;
9541    tnlEvt.remTeid = teId;
9542    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9543    if(ret != ROK)
9544    {
9545       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9546    }
9547    return ROK;
9548 }
9549
9550 /****************************************************************
9551  * @brief Function to process Drb Setup List
9552  *
9553  * @details
9554  *
9555  *    Function : procDrbSetupList
9556  *
9557  *    Functionality:
9558  *         - Function to process DRB Setup List
9559  *
9560  * @params[in]
9561  * @return ROK     - success
9562  *         RFAILED - failure
9563  *
9564  * ****************************************************************/
9565 uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
9566 {
9567    uint8_t arrIdx = 0, drbIdx = 0;
9568    uint32_t teId = 0;
9569    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9570
9571    if(drbSetupList != NULLP)
9572    {
9573       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9574       {
9575          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9576          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9577          {
9578             /* extracting teId */
9579             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9580             if(teId > 0)
9581             {
9582                if(addDrbTunnels(duId, teId)== ROK)
9583                {
9584                   DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9585                }
9586                /* As per Spec 38.473, in UE COntext Response, Tunnel information
9587                 * are sent to CU for setting up of Tunnels in DL direction.
9588                 * Search for DRB ID in CU databse */
9589                for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
9590                {
9591                   if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
9592                   {
9593                      fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
9594                      break;
9595                   }
9596                }
9597             }
9598             else
9599                return RFAILED;
9600          }
9601       }
9602    }
9603    return ROK;
9604 }
9605
9606 /****************************************************************
9607  * @brief Function to process Ue Context Setup Response
9608  *
9609  * @details
9610  *
9611  *    Function : procUeContextSetupResponse
9612  *
9613  *    Functionality:
9614  *         - Function to process Ue Context Setup Response
9615  *
9616  * @params[in]
9617  * @return ROK     - success
9618  *         RFAILED - failure
9619  *
9620  * ****************************************************************/
9621 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9622 {
9623    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9624    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9625    DuDb *duDb = NULLP;
9626    CuUeCb *ueCb = NULLP;
9627    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9628    OCTET_STRING_t *duToCuRrcContainer;
9629
9630    SEARCH_DU_DB(duIdx, duId, duDb);
9631    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9632
9633    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9634    {
9635       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9636       {
9637           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9638              {
9639                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9640                break;
9641              }
9642           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9643              {
9644                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9645                 ueCb = &duDb->ueCb[duUeF1apId-1];
9646                 /* If ue context is not present in du db, then create UE context
9647                  * here. This flow is hit in case of UE handover where UE
9648                  * context is created before UE performs RACH on target DU */
9649                 if(ueCb->gnbDuUeF1apId == 0)
9650                 {
9651                    /* Creating UE context in target DU */
9652                    memset(ueCb, 0, sizeof(CuUeCb));
9653                    ueCb->cellCb = &duDb->cellCb[0];
9654                    ueCb->gnbDuUeF1apId = duUeF1apId;
9655                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9656                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9657                    ueCb->hoInfo.targetDuId = duId;
9658                    (duDb->numUe)++;
9659
9660                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9661                    ueCb->cellCb->numUe++;
9662                 }
9663                 break;
9664              }
9665           case ProtocolIE_ID_id_C_RNTI:
9666              {
9667                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9668                 break;
9669              }
9670           case ProtocolIE_ID_id_DRBs_Setup_List:
9671              {
9672                 /* Adding Tunnels for successful DRB */
9673                 procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9674                 break;
9675              }
9676          case ProtocolIE_ID_id_DUtoCURRCInformation:
9677              {
9678                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9679                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9680                    DUtoCURRCInformation.cellGroupConfig;
9681                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9682                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9683                 {
9684                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9685                    return RFAILED;
9686                 }
9687                 break;
9688              }
9689       }
9690    }
9691
9692    /* If the UE is in handover, UE context modification request is to be sent to
9693     * source DU once UE context setup response is received from target DU */
9694    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9695    {
9696       DuDb *srcDuDb = NULLP;
9697       CuUeCb *ueCbInSrcDu = NULLP;
9698
9699       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9700        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9701       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9702       {
9703          /* UE context setup response is received from target DU. Search all
9704           * DUs to find source DU except this target DU Id.*/
9705          if(cuCb.duInfo[duIdx].duId != duId)
9706          {
9707             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9708             {
9709                /* Check following:
9710                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9711                 * received in UE context setup response since CU UE F1AP ID does not
9712                 * change for UE in handover.
9713                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9714                 */
9715                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9716                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9717                {
9718                   srcDuDb = &cuCb.duInfo[duIdx];
9719                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9720
9721                   /* Store source DU info in the new UE context created in
9722                    * tareget DU */
9723                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9724
9725                   /* Copy the received container to UeCb */
9726                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9727
9728                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9729                   {
9730                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9731                      return RFAILED;
9732                   }
9733                   break;
9734                }
9735             }
9736          }
9737          if(srcDuDb && ueCbInSrcDu)
9738             break;
9739       }
9740    }
9741    else
9742    {
9743       ueCb->f1apMsgDb.dlRrcMsgCount++;
9744       rrcMsgType = setDlRRCMsgType(ueCb);
9745
9746       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9747       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9748       {
9749          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9750          return RFAILED;
9751       }
9752    }
9753
9754    return ROK;
9755 }
9756
9757 /****************************************************************
9758  * @brief Function to process Ul Rrc Msg received from DU
9759  *
9760  * @details
9761  *
9762  *    Function : procUlRrcMsg
9763  *
9764  *    Functionality:
9765  *         - Function to process Ul Rrc Msg received from DU
9766  *
9767  * @params[in]
9768  * @return ROK     - success
9769  *         RFAILED - failure
9770  *
9771  * ****************************************************************/
9772
9773 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9774 {
9775    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9776    uint8_t  *rrcContainer = NULLP;
9777    uint16_t rrcContLen = 0;
9778    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9779    DuDb     *duDb = NULLP;
9780    CuUeCb   *ueCb = NULLP;
9781    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9782
9783    ret = ROK;
9784    SEARCH_DU_DB(duIdx, duId, duDb);
9785    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9786
9787    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9788    {
9789       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9790       {
9791          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9792             {
9793                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9794                break;
9795             }
9796          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9797             {
9798                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9799                break;
9800             }
9801          case ProtocolIE_ID_id_SRBID:
9802             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9803             break;
9804
9805          case ProtocolIE_ID_id_RRCContainer:
9806             {
9807                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9808                CU_ALLOC(rrcContainer, rrcContLen);
9809                if(!rrcContainer)
9810                {
9811                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9812                   return RFAILED;
9813                }
9814                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9815
9816                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9817                {
9818                   uint8_t ueIdx = 0;
9819                   uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.sourceDuId;
9820                   DuDb *srcDuDb = NULLP;
9821
9822                   /* In target DU DB, mark UE as active and delete HO info */
9823                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9824                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9825
9826                   /* Release UE context in source DU because the UE is now
9827                    * attached to target DU */
9828                   SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9829                   for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9830                   {
9831                      if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9832                      {
9833                         ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9834                         if(ret != ROK)
9835                         {
9836                            DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9837                         }
9838                         break;
9839                      }
9840                   }
9841                   return ret;
9842                }
9843                break;
9844             }
9845
9846          default:
9847             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9848             break;
9849       }
9850    }
9851
9852    if(srbId == 1)
9853    {
9854       ueCb = &duDb->ueCb[duUeF1apId-1];
9855       ueCb->f1apMsgDb.dlRrcMsgCount++;
9856       rrcMsgType = setDlRRCMsgType(ueCb);
9857       if(rrcMsgType == REGISTRATION_COMPLETE)
9858       {
9859          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9860          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9861       }
9862       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9863       {
9864          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9865          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9866       }
9867       else
9868       {
9869          /* In case rrcMsgType is RRC_SETUP_COMPLETE / NAS_AUTHENTICATION_RSP / NAS_SECURITY_MODE_COMPLETE / RRC_SECURITY_MODE_COMPLETE */
9870          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9871       }
9872    }
9873    return ret;
9874 }
9875
9876 /****************************************************************
9877  * @brief Build And Send F1ResetAck
9878  *
9879  * @details
9880  *
9881  *    Function : FreeF1ResetAck
9882  *
9883  *    Functionality:
9884  *         - Build And Send  F1ResetRSP
9885  *
9886  *  @params[in]
9887  * @return ROK     - success
9888  *         RFAILED - failure
9889  *
9890  * ****************************************************************/
9891 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9892 {
9893    uint8_t idx;
9894    ResetAcknowledge_t *f1ResetAck;
9895
9896    if(f1apMsg)
9897    {
9898       if(f1apMsg->choice.successfulOutcome)
9899       {
9900          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9901
9902          if(f1ResetAck->protocolIEs.list.array)
9903          {
9904             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9905             {
9906                if(f1ResetAck->protocolIEs.list.array[idx])
9907                {
9908                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9909                }
9910             }
9911             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9912          }
9913          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9914       }
9915       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9916    }
9917 }
9918
9919 /****************************************************************
9920  * @brief Build And Send F1ResetAck
9921  *
9922  * @details
9923  *
9924  *    Function : BuildAndSendF1ResetAck
9925  *
9926  *    Functionality:
9927  *         - Build And Send  F1ResetRSP
9928  *
9929  *  @params[in]
9930  * @return ROK     - success
9931  *         RFAILED - failure
9932  *
9933  * ****************************************************************/
9934
9935 uint8_t BuildAndSendF1ResetAck()
9936 {
9937    uint8_t                idx = 0;
9938    uint8_t                elementCnt = 0;
9939    uint8_t                ret = RFAILED;
9940    F1AP_PDU_t             *f1apMsg = NULL;
9941    ResetAcknowledge_t     *f1ResetAck = NULLP;
9942    asn_enc_rval_t         encRetVal;
9943    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9944
9945    do{
9946       /* Allocate the memory for F1ResetRequest_t */
9947       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9948       if(f1apMsg == NULLP)
9949       {
9950          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9951          break;
9952       }
9953
9954       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9955
9956       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9957       if(f1apMsg->choice.successfulOutcome == NULLP)
9958       {
9959          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9960          break;
9961       }
9962
9963       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9964       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9965       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9966       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9967
9968       elementCnt = 1;
9969
9970       f1ResetAck->protocolIEs.list.count = elementCnt;
9971       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9972
9973       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9974       if(f1ResetAck->protocolIEs.list.array == NULLP)
9975       {
9976          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9977          break;
9978       }
9979
9980       for(idx=0; idx<elementCnt; idx++)
9981       {
9982          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9983          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9984          {
9985             break;
9986          }
9987       }
9988       /*TransactionID*/
9989       idx = 0;
9990       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9991       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9992       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9993       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9994
9995       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9996
9997       /* Encode the F1SetupRequest type as UPER */
9998       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9999       encBufSize = 0;
10000       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10001
10002       /* Check encode results */
10003       if(encRetVal.encoded == ENCODE_FAIL)
10004       {
10005          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10006                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10007          break;
10008       }
10009       else
10010       {
10011          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
10012          for(int i=0; i< encBufSize; i++)
10013          {
10014             DU_LOG("%x",encBuf[i]);
10015          }
10016       }
10017
10018       /* Sending msg */
10019       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10020       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
10021       {
10022          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
10023          break;
10024       }
10025
10026       ret = ROK;
10027       break;
10028    }while(true);
10029
10030    FreeF1ResetAck(f1apMsg);
10031    return ret;
10032 }
10033
10034 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10035 {
10036    uint8_t arrIdx =0;
10037
10038    if(ulInfo->list.array)
10039    {
10040       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
10041       {
10042          if(ulInfo->list.array[arrIdx])
10043          {
10044             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
10045             {
10046                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
10047                {
10048                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
10049                   {
10050                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10051                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10052                      gTPTunnel->gTP_TEID.size);
10053                   }
10054                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10055                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10056                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10057                }
10058                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10059                sizeof(GTPTunnel_t));
10060             }
10061             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10062          }
10063       }
10064       CU_FREE(ulInfo->list.array,ulInfo->list.size);
10065    }
10066 }
10067
10068 /*******************************************************************
10069 *
10070 * @brief Deletes the EGTP tunnel
10071 *
10072 * @details
10073 *
10074 *    Function : deleteEgtpTunnel
10075 *
10076 *    Functionality: Deletes the EGTP tunnel
10077 *
10078 * @params[in] uint8_t *buf
10079 *
10080 * @return ROK     - success
10081 *         RFAILED - failure
10082 *
10083 * ****************************************************************/
10084 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
10085 {
10086    uint32_t teId = 0;
10087    EgtpTnlEvt tnlEvt;
10088
10089    teIdStringToInt(buf, &teId);
10090    if(teId > MAX_TEID || teId < MIN_TEID)
10091    {
10092       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
10093       return RFAILED;
10094    }
10095    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
10096    tnlEvt.action = EGTP_TNL_MGMT_DEL;
10097    tnlEvt.lclTeid = teId;
10098    tnlEvt.remTeid = teId;
10099    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
10100    {
10101       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
10102    }
10103    return ROK;
10104 }
10105
10106 /*******************************************************************
10107 *
10108 * @brief Builds the Uplink Tunnel Info
10109 *
10110 * @details
10111 *
10112 *    Function : BuildUlTnlInfoforSetupMod
10113 *
10114 *    Functionality: Constructs the UL TnlInfo For DRB list
10115 *
10116 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10117 *
10118 * @return ROK     - success
10119 *         RFAILED - failure
10120 *
10121 * ****************************************************************/
10122 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
10123 {
10124    uint8_t arrIdx;
10125    uint8_t ulCnt;
10126
10127    ulCnt = 1;
10128    ulInfo->list.count = ulCnt;
10129    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
10130    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
10131    if(ulInfo->list.array == NULLP)
10132    {
10133       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10134       return RFAILED;
10135    }
10136    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
10137    {
10138       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10139       if(ulInfo->list.array[arrIdx] == NULLP)
10140       {
10141          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10142          return RFAILED;
10143       }
10144    }
10145
10146    arrIdx = 0;
10147    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
10148    UPTransportLayerInformation_PR_gTPTunnel;
10149
10150    /*GTP TUNNEL*/
10151    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10152          sizeof(GTPTunnel_t));
10153    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
10154    {
10155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10156       return RFAILED;
10157    }
10158    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10159       transportLayerAddress.size        = 4*sizeof(uint8_t);
10160    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10161          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10162          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10163    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10164          transportLayerAddress.buf == NULLP)
10165    {
10166       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10167       return RFAILED;
10168    }
10169
10170    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10171       transportLayerAddress.buf[0] = 192;
10172    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10173       transportLayerAddress.buf[1] = 168;
10174    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10175       transportLayerAddress.buf[2] = 130;
10176    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10177       transportLayerAddress.buf[3] = 82;
10178    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10179       transportLayerAddress.bits_unused = 0;
10180
10181    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
10182    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
10183    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
10184    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
10185
10186    /*GTP TEID*/
10187    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
10188       = 4 * sizeof(uint8_t);
10189    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10190          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10191          gTPTunnel->gTP_TEID.size);
10192    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10193          == NULLP)
10194    {
10195       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10196       return RFAILED;
10197    }
10198    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10199       gTP_TEID.buf[0] = 0;
10200    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10201       gTP_TEID.buf[1] = 0;
10202    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10203       gTP_TEID.buf[2] = 0;
10204    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
10205    {
10206      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
10207       * fetched based on the Drb Id */
10208
10209      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
10210       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
10211                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
10212    }
10213    else
10214    {
10215       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10216         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
10217    }
10218
10219    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
10220    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
10221    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
10222    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
10223    return ROK;
10224 }/*End of BuildULTnlInfo*/
10225
10226 /*******************************************************************
10227 *
10228 * @brief freeing the DRB item
10229 *
10230 * @details
10231 *
10232 *    Function : FreeDrbItem
10233 *
10234 *    Functionality: freeing the DRB item
10235 *
10236 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10237 *
10238 * @return ROK     - success
10239 *         RFAILED - failure
10240 *
10241 * ****************************************************************/
10242
10243 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
10244 {
10245    uint8_t arrIdx =0;
10246    SNSSAI_t *snssai =NULLP;
10247    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10248
10249    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10250    switch(drbItem->qoSInformation.present)
10251    {
10252       case QoSInformation_PR_NOTHING:
10253          break;
10254       case QoSInformation_PR_eUTRANQoS:
10255          {
10256             if(drbItem->qoSInformation.choice.eUTRANQoS)
10257             {
10258                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10259             }
10260             break;
10261          }
10262       case QoSInformation_PR_choice_extension:
10263          {
10264             if(drbItem->qoSInformation.choice.choice_extension)
10265             {
10266                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10267
10268                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10269                if(snssai->sST.buf)
10270                {
10271                   CU_FREE(snssai->sST.buf,snssai->sST.size);
10272                }
10273                if(snssai->sD)
10274                {
10275                   if(snssai->sD->buf)
10276                   {
10277                      CU_FREE(snssai->sD->buf,snssai->sD->size);
10278                   }
10279                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10280                }
10281
10282                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10283                if(flowMap->list.array)
10284                {
10285                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10286                   {
10287                      if(flowMap->list.array[arrIdx] )
10288                      {
10289                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10290                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10291                      }
10292                   }
10293                   CU_FREE(flowMap->list.array,flowMap->list.size);
10294                }
10295
10296                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10297             }
10298             break;
10299          }
10300
10301    }
10302    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10303    if(drbItem->uLConfiguration)
10304    {
10305       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10306    }
10307 }
10308
10309 /*******************************************************************
10310 *
10311 * @brief filling the DRB setup Mod item
10312 *
10313 * @details
10314 *
10315 *    Function : FillDrbItemToSetupMod
10316 *
10317 *    Functionality: filling the DRB setup Mod item
10318 *
10319 *
10320 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10321 *
10322 * @return ROK     - success
10323 *         RFAILED - failure
10324 *
10325 * ****************************************************************/
10326
10327 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
10328 {
10329    uint8_t ret = ROK;
10330
10331    /*Drb Id */
10332    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
10333    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
10334
10335    /*qoSInformation*/
10336    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10337
10338    switch(drbItem->qoSInformation.present)
10339    {
10340       case QoSInformation_PR_NOTHING:
10341       {
10342          break;
10343       }
10344       case QoSInformation_PR_eUTRANQoS:
10345       {
10346
10347          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10348          if(drbItem->qoSInformation.choice.eUTRANQoS)
10349          {
10350             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10351             return RFAILED;
10352          }
10353          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10354          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10355             PriorityLevel_no_priority;
10356
10357          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10358             Pre_emptionCapability_may_trigger_pre_emption;
10359
10360          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10361             Pre_emptionVulnerability_pre_emptable;
10362
10363          break;
10364       }
10365       case QoSInformation_PR_choice_extension:
10366       {
10367          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10368          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10369          {
10370             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10371             return RFAILED;
10372          }
10373
10374          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10375          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10376          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10377          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10378            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10379          if(ret != ROK)
10380          {
10381             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10382             return RFAILED;
10383          }
10384
10385          /*SNSSAI*/
10386          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10387                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10388          if(ret != ROK)
10389          {
10390             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10391             return RFAILED;
10392          }
10393
10394          /*Flows mapped to DRB List*/
10395          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10396                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10397           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10398          if(ret != ROK)
10399          {
10400             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10401             return RFAILED;
10402          }
10403       }
10404    }
10405
10406    /*ULUPTNLInformation To Be Setup List*/
10407    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10408       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10409    if(ret != ROK)
10410    {
10411       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10412       return RFAILED;
10413    }
10414
10415    /*RLCMode*/
10416    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10417    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10418
10419    ueCb->numDrb++;
10420    return ROK;
10421 }
10422
10423 /*******************************************************************
10424 *
10425 * @brief Builds the DRB to be Setup Mod ItemIes
10426 *
10427 * @details
10428 *
10429 *    Function : FillDrbItemList
10430 *
10431 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10432 *
10433 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10434 *
10435 * @return ROK     - success
10436 *         RFAILED - failure
10437 *
10438 * ****************************************************************/
10439
10440 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10441 {
10442    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10443    drbItemIe->criticality = Criticality_reject;
10444    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10445
10446    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10447    {
10448       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10449       return RFAILED;
10450    }
10451    return ROK;
10452 }
10453 /*******************************************************************
10454 *
10455 * @brief free the DRB to be Setup Mod list
10456 *
10457 * @details
10458 *
10459 *    Function : FreeDrbToBeSetupModList
10460 *
10461 *    Functionality: free the DRB to be Setup Mod list
10462 *
10463 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10464 *
10465 * @return ROK     - success
10466 *         RFAILED - failure
10467 *
10468 * ****************************************************************/
10469 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10470 {
10471    uint8_t arrIdx =0;
10472    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10473
10474    if(drbSet->list.array)
10475    {
10476       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10477       {
10478          if(drbSet->list.array[arrIdx] != NULLP)
10479          {
10480             if(arrIdx == 0)
10481             {
10482                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10483                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10484             }
10485             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10486          }
10487       }
10488       CU_FREE(drbSet->list.array, drbSet->list.size);
10489    }
10490
10491 }
10492
10493 /*******************************************************************
10494 *
10495 * @brief Builds the DRB to be Setup Mod list
10496 *
10497 * @details
10498 *
10499 *    Function : BuildDrbToBeSetupList
10500 *
10501 *    Functionality: Constructs the DRB to be Setup Mod list
10502 *
10503 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10504 *
10505 * @return ROK     - success
10506 *         RFAILED - failure
10507 *
10508 * ****************************************************************/
10509
10510 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10511 {
10512    uint8_t ret = ROK;
10513    uint8_t arrIdx =0;
10514    uint8_t drbCnt =0;
10515
10516    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10517    drbSet->list.count = drbCnt;
10518    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10519    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10520    if(drbSet->list.array == NULLP)
10521    {
10522       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10523       return  RFAILED;
10524    }
10525
10526    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10527    {
10528       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10529       if(drbSet->list.array[arrIdx] == NULLP)
10530       {
10531          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10532          return  RFAILED;
10533       }
10534
10535       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10536       if(ret != ROK)
10537       {
10538          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10539       }
10540    }
10541
10542    return ret;
10543 }
10544
10545 /*******************************************************************
10546 *
10547 * @brief Filling the DRB to be modified item
10548 *
10549 * @details
10550 *
10551 *    Function : FillDrbToBeModItem
10552 *
10553 *    Functionality: filling the DRB to be modified item
10554 *
10555 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10556 *
10557 * @return ROK     - success
10558 *         RFAILED - failure
10559 *
10560 * ****************************************************************/
10561
10562 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10563 {
10564    uint8_t ret = ROK;
10565    uint drbIdx=0;
10566    DrbInfo *drbToBeMod;
10567
10568    /*Drb Id */
10569    drbItem->dRBID = DRB2 + arrIdx;
10570
10571    /* Search for DRB ID in CU databse */
10572    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10573    {
10574       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10575       {
10576          drbToBeMod = &ueCb->drbList[drbIdx];
10577          break;
10578       }
10579    }
10580
10581    /*qoSInformation*/
10582    drbItem->qoSInformation = NULLP;
10583    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10584    if(drbItem->qoSInformation != NULLP)
10585    {
10586       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10587
10588       switch(drbItem->qoSInformation->present)
10589       {
10590          case QoSInformation_PR_NOTHING:
10591             {
10592                break;
10593             }
10594          case QoSInformation_PR_eUTRANQoS:
10595             {
10596
10597                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10598                if(drbItem->qoSInformation->choice.eUTRANQoS)
10599                {
10600                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10601                   return RFAILED;
10602                }
10603                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10604                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10605                   PriorityLevel_no_priority;
10606
10607                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10608                   Pre_emptionCapability_may_trigger_pre_emption;
10609
10610                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10611                   Pre_emptionVulnerability_pre_emptable;
10612
10613                break;
10614             }
10615          case QoSInformation_PR_choice_extension:
10616             {
10617                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10618                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10619                {
10620                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10621                   return RFAILED;
10622                }
10623
10624                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10625                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10626                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10627                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10628                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10629                if(ret != ROK)
10630                {
10631                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10632                   return RFAILED;
10633                }
10634
10635                /*SNSSAI*/
10636                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10637                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10638                if(ret != ROK)
10639                {
10640                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10641                   return RFAILED;
10642                }
10643
10644                /*Flows mapped to DRB List*/
10645                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10646                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10647                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10648                if(ret != ROK)
10649                {
10650                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10651                   return RFAILED;
10652                }
10653             }
10654       }
10655    }/* End of QoS */
10656
10657    /*ULUPTNLInformation To Be Setup List*/
10658    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10659             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10660    if(ret != ROK)
10661    {
10662       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10663       return RFAILED;
10664    }
10665    return ROK;
10666 }
10667
10668 /*******************************************************************
10669 *
10670 * @brief Builds the DRB to be modified Item IE
10671 *
10672 * @details
10673 *
10674 *    Function : FillDrbToBeModItemList
10675 *
10676 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10677 *
10678 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10679 *
10680 * @return ROK     - success
10681 *         RFAILED - failure
10682 *
10683 * ****************************************************************/
10684
10685 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10686 {
10687    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10688    drbItemIe->criticality = Criticality_reject;
10689    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10690    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10691    {
10692       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10693       return RFAILED;
10694    }
10695
10696    return ROK;
10697 }
10698
10699 /*******************************************************************
10700 *
10701 * @brief Builds the DRB to be modified list
10702 *
10703 * @details
10704 *
10705 *    Function : BuildDrbToBeModList
10706 *
10707 *    Functionality: Constructs the DRB to be modified list
10708 *
10709 * @params[in] DRBs_ToBeModified_List_t *drbSet
10710 *
10711 * @return ROK     - success
10712 *         RFAILED - failure
10713 *
10714 * ****************************************************************/
10715
10716 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10717 {
10718    uint8_t ret = ROK;
10719    uint8_t arrIdx =0;
10720    uint8_t drbCnt =0;
10721
10722    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10723    drbSet->list.count = drbCnt;
10724    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10725    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10726    if(drbSet->list.array == NULLP)
10727    {
10728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10729       return  RFAILED;
10730    }
10731    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10732    {
10733       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10734       if(drbSet->list.array[arrIdx] == NULLP)
10735       {
10736          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10737          return  RFAILED;
10738       }
10739
10740       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10741       if(ret != ROK)
10742       {
10743          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10744       }
10745    }
10746
10747    return ret;
10748 }
10749
10750 /*******************************************************************
10751 *
10752 * @brief Builds the DRB to be released Item IE
10753 *
10754 * @details
10755 *
10756 *    Function : FillDrbToBeRelItemList
10757 *
10758 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10759 *
10760 * @params[in] struct DRBs_ToBeReleased_ItemIEs *drbItemIe
10761 *
10762 * @return ROK     - success
10763 *         RFAILED - failure
10764 *
10765 * ****************************************************************/
10766
10767 uint8_t FillDrbToBeRelItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeReleased_ItemIEs *drbItemIe)
10768 {
10769    uint8_t drbIdx;
10770
10771    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeReleased_Item;
10772    drbItemIe->criticality = Criticality_reject;
10773    drbItemIe->value.present = DRBs_ToBeReleased_ItemIEs__value_PR_DRBs_ToBeReleased_Item;
10774    drbItemIe->value.choice.DRBs_ToBeReleased_Item.dRBID = DRB1 + arrIdx;
10775
10776    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10777    {
10778       if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_ToBeReleased_Item.dRBID)
10779       {
10780          deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
10781          CU_FREE(ueCb->drbList[drbIdx].snssai, sizeof(Snssai));
10782          break;
10783       }
10784    }
10785    return ROK;
10786 }
10787
10788 /*******************************************************************
10789 *
10790 * @brief Builds the DRB to be released list
10791 *
10792 * @details
10793 *
10794 *    Function : BuildDrbToBeReleasedList
10795 *
10796 *    Functionality: Constructs the DRB to be released list
10797 *
10798 * @params[in] DRBs_ToBeReleased_List_t *drbSet
10799 *
10800 * @return ROK     - success
10801 *         RFAILED - failure
10802 *
10803 * ****************************************************************/
10804
10805 uint8_t BuildDrbToBeReleasedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeReleased_List_t *drbSet)
10806 {
10807    uint8_t ret = ROK;
10808    uint8_t arrIdx =0;
10809    uint8_t drbCnt =0;
10810
10811    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10812    drbSet->list.count = drbCnt;
10813    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeReleased_ItemIEs_t *);
10814    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10815    if(drbSet->list.array == NULLP)
10816    {
10817       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
10818       return  RFAILED;
10819    }
10820    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10821    {
10822       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeReleased_ItemIEs_t));
10823       if(drbSet->list.array[arrIdx] == NULLP)
10824       {
10825          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
10826          return  RFAILED;
10827       }
10828
10829       ret = FillDrbToBeRelItemList(duId, ueCb, arrIdx, (DRBs_ToBeReleased_ItemIEs_t *)drbSet->list.array[arrIdx]);
10830       if(ret != ROK)
10831       {
10832          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeRelItemList failed");
10833       }
10834    }
10835
10836    return ret;
10837 }
10838
10839 /*******************************************************************
10840 *
10841 * @brief freeing the DRB  item
10842 *
10843 * @details
10844 *
10845 *    Function : FreeModifiedDrbItem
10846 *
10847 *    Functionality: freeing the DRB 2 item
10848 *
10849 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10850 *
10851 * @return ROK     - success
10852 *         RFAILED - failure
10853 *
10854 * ****************************************************************/
10855
10856 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10857 {
10858    uint8_t arrIdx =0;
10859    SNSSAI_t *snssai =NULLP;
10860    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10861
10862    if(drbItem->qoSInformation != NULLP)
10863    {
10864       switch(drbItem->qoSInformation->present)
10865       {
10866          case QoSInformation_PR_NOTHING:
10867             break;
10868          case QoSInformation_PR_eUTRANQoS:
10869             {
10870                if(drbItem->qoSInformation->choice.eUTRANQoS)
10871                {
10872                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10873                }
10874                break;
10875             }
10876          case QoSInformation_PR_choice_extension:
10877             {
10878                if(drbItem->qoSInformation->choice.choice_extension)
10879                {
10880                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10881
10882                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10883                   if(snssai->sST.buf)
10884                   {
10885                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10886                   }
10887                   if(snssai->sD)
10888                   {
10889                      if(snssai->sD->buf)
10890                      {
10891                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10892                      }
10893                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10894                   }
10895
10896                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10897                   if(flowMap->list.array)
10898                   {
10899                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10900                      {
10901                         if(flowMap->list.array[arrIdx] )
10902                         {
10903                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10904                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10905                         }
10906                      }
10907                      CU_FREE(flowMap->list.array,flowMap->list.size);
10908                   }
10909
10910                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10911                }
10912                break;
10913             }
10914       }
10915    }
10916    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10917    if(drbItem->uLConfiguration)
10918    {
10919       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10920    }
10921 }
10922
10923 /*******************************************************************
10924 *
10925 * @brief free the DRB to be modfified list
10926 *
10927 * @details
10928 *
10929 *    Function : FreeDrbToBeModifiedList
10930 *
10931 *    Functionality: free the DRB to be Setup Mod list
10932 *
10933 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10934 *
10935 * @return ROK     - success
10936 *         RFAILED - failure
10937 *
10938 * ****************************************************************/
10939 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10940 {
10941    uint8_t arrIdx =0;
10942    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10943
10944    if(drbSet->list.array)
10945    {
10946       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10947       {
10948          if(drbSet->list.array[arrIdx] != NULLP)
10949          {
10950             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10951             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10952             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10953          }
10954       }
10955       CU_FREE(drbSet->list.array, drbSet->list.size);
10956    }
10957
10958 }
10959
10960 /*******************************************************************
10961 *
10962 * @brief free the DRB to be modfified list
10963 *
10964 * @details
10965 *
10966 *    Function : FreeDrbToBeReleasedList
10967 *
10968 *    Functionality: free the DRB to be Release list
10969 *
10970 * @params[in] FreeDrbToBeReleasedList_t *drbSet
10971 *
10972 * @return ROK     - success
10973 *         RFAILED - failure
10974 *
10975 * ****************************************************************/
10976 void FreeDrbToBeReleasedList(DRBs_ToBeReleased_List_t *drbSet)
10977 {
10978    uint8_t arrIdx =0;
10979    struct DRBs_ToBeReleased_ItemIEs *drbItemIe;
10980
10981    if(drbSet->list.array)
10982    {
10983       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10984       {
10985          if(drbSet->list.array[arrIdx] != NULLP)
10986          {
10987             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeReleased_ItemIEs_t));
10988          }
10989       }
10990       CU_FREE(drbSet->list.array, drbSet->list.size);
10991    }
10992 }
10993
10994 /*******************************************************************
10995  *
10996  * @brief  free the UeContextModification Request
10997  *
10998  * @details
10999  *
11000  *    Function : FreeUeContextModicationRequest
11001  *
11002  *    Functionality : deallocation of memory allocated in UeContextModiification
11003  request
11004  *
11005  * @params[in] F1AP_PDU_t *f1apMsg
11006  *
11007  * @return void
11008 *
11009 * ****************************************************************/
11010 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
11011 {
11012    uint8_t arrIdx =0 , ieId=0;
11013    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
11014
11015    if(f1apMsg)
11016    {
11017       if(f1apMsg->choice.initiatingMessage)
11018       {
11019          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
11020          if(ueContextModifyReq->protocolIEs.list.array)
11021          {
11022             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
11023             {
11024                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
11025                {
11026                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
11027                   switch(ieId)
11028                   {
11029                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11030                         break;
11031                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11032                         break;
11033                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
11034                         {
11035                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11036                                  choice.DRBs_ToBeSetupMod_List);
11037                            break;
11038                         }
11039                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
11040                         {
11041                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11042                                  choice.DRBs_ToBeModified_List);
11043                            break;
11044                         }
11045                      case ProtocolIE_ID_id_DRBs_ToBeReleased_List:
11046                         {
11047                            FreeDrbToBeReleasedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11048                                  choice.DRBs_ToBeReleased_List);
11049                            break;
11050                         }
11051                     case ProtocolIE_ID_id_TransmissionActionIndicator:
11052                         break;
11053                     case ProtocolIE_ID_id_RRCContainer:
11054                     {
11055                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
11056                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
11057                     }
11058
11059                   }
11060                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
11061                }
11062             }
11063             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
11064          }
11065          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11066       }
11067       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11068    }
11069 }
11070
11071 /*******************************************************************
11072  *
11073  * @brief Builds the Ue Context Modification Req
11074  *
11075  * @details
11076  *
11077  *    Function : BuildAndSendUeContextModificationReq
11078  *
11079  *    Functionality: Constructs the Ue Context Modification Req
11080  *
11081  * @params[in]
11082  *
11083  * @return ROK     - success
11084  *         RFAILED - failure
11085  *
11086  * ****************************************************************/
11087 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
11088 {
11089    uint8_t    ieIdx = 0;
11090    uint8_t    elementCnt = 0;
11091    uint8_t    ret = RFAILED;
11092    uint16_t   tmpBufIdx = 0, bufIdx = 0;
11093    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
11094    F1AP_PDU_t *f1apMsg = NULLP;
11095    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
11096    RRCContainer_t rrcContainerTmp, *rrcContainer = NULLP;
11097    asn_enc_rval_t         encRetVal;
11098    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
11099    while(1)
11100    {
11101       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11102       if(f1apMsg == NULLP)
11103       {
11104          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11105          break;
11106       }
11107
11108       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11109
11110       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11111       if(f1apMsg->choice.initiatingMessage == NULLP)
11112       {
11113          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11114          break;
11115       }
11116       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
11117       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11118       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
11119
11120       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
11121
11122       if(action == MODIFY_UE)
11123          elementCnt = 5;
11124       else if(action == QUERY_CONFIG)
11125          elementCnt = 3;
11126       else if(action == RRC_RECONFIG_COMPLETE_IND)
11127          elementCnt = 3;
11128       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11129          elementCnt = 5;
11130
11131 #ifdef NR_DRX
11132       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
11133          elementCnt++;
11134 #endif
11135       ueContextModifyReq->protocolIEs.list.count = elementCnt;
11136       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
11137
11138       /* Initialize the UE context modification members */
11139       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
11140       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
11141       {
11142          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11143          break;
11144       }
11145
11146       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11147       {
11148          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
11149          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
11150          {
11151             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11152             break;
11153          }
11154       }
11155
11156       ieIdx=0;
11157       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11158       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11159       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11160                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
11161       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
11162
11163       ieIdx++;
11164       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11165       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11166       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
11167                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
11168       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
11169
11170       if(action == MODIFY_UE)
11171       {
11172          /* DRB to be setup list */
11173          ieIdx++;
11174          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
11175          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11176          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11177                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
11178          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11179                   value.choice.DRBs_ToBeSetupMod_List));
11180
11181          /* DRB to be modified list */
11182          ieIdx++;
11183          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
11184          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11185          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11186                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
11187          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11188                   value.choice.DRBs_ToBeModified_List));
11189
11190          if(ret != ROK)
11191          {
11192             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
11193             break;
11194          }
11195
11196          /* DRB to be released list */
11197          ieIdx++;
11198          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeReleased_List;
11199          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11200          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11201                                                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeReleased_List;
11202          ret = BuildDrbToBeReleasedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11203                   value.choice.DRBs_ToBeReleased_List));
11204
11205          if(ret != ROK)
11206          {
11207             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be deleted list");
11208             break;
11209          }
11210       }
11211       else if(action == QUERY_CONFIG)
11212       {
11213          ieIdx++;
11214          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
11215          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11216          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11217             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
11218          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
11219       }
11220       else if(action == RRC_RECONFIG_COMPLETE_IND)
11221       {
11222          ieIdx++;
11223          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
11224          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11225          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11226             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
11227          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
11228             RRCReconfigurationCompleteIndicator_true;
11229       }
11230       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11231       {
11232          ieIdx++;
11233          if(action == STOP_DATA_TX)
11234          {
11235             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11236             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11237             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11238             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11239             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11240             TransmissionActionIndicator_stop;
11241          }
11242          else if (action == RESTART_DATA_TX)
11243          {
11244             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11245             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11246             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11247             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11248             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11249             TransmissionActionIndicator_restart;
11250          }
11251
11252          ieIdx++;
11253          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11254          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11255          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCContainer;
11256          if(fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, true) != ROK)
11257          {
11258             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
11259             return RFAILED;
11260          }
11261
11262          rrcContainer = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11263          rrcContainer->size = rrcContainerTmp.size + 2; /* 2 bytes of PDCP SN */
11264          CU_ALLOC(rrcContainer->buf, rrcContainer->size);
11265          memset(rrcContainer->buf, 0, rrcContainer->size);
11266          rrcContainer->buf[0] = 0x00;
11267          rrcContainer->buf[1] = ueCb->pdcpSn; //PDCP SN
11268          for(bufIdx = 2, tmpBufIdx = 0; bufIdx < rrcContainer->size; bufIdx++, tmpBufIdx++)
11269          {
11270             rrcContainer->buf[bufIdx] = rrcContainerTmp.buf[tmpBufIdx];
11271          }
11272
11273          /* RRC delivery status request */
11274          ieIdx++;
11275          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
11276          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11277          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
11278          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
11279       }
11280
11281 #ifdef NR_DRX
11282       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
11283       {
11284          /* DRX Configuration Indicator */
11285          ieIdx++;
11286          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRXConfigurationIndicator;
11287          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11288          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_DRXConfigurationIndicator;
11289          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.DRXConfigurationIndicator = DRXConfigurationIndicator_release;
11290          ueCb->drxCfgPresent = false;
11291          memset(&ueCb->drxCfg, 0, sizeof(DrxCfg));
11292       }
11293 #endif
11294
11295       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11296
11297       /* Encode the F1SetupRequest type as APER */
11298       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11299       encBufSize = 0;
11300       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11301
11302       /* Encode results */
11303       if(encRetVal.encoded == ENCODE_FAIL)
11304       {
11305          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
11306                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11307          break;
11308       }
11309       else
11310       {
11311          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
11312 #if 0
11313          /* This for loop was going into an infinite loop even though encBufSize
11314           * has a small value. Hence commented this
11315           */
11316          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11317          {
11318             DU_LOG("%x",encBuf[ieIdx]);
11319          }
11320 #endif
11321       }
11322
11323       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11324       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11325       {
11326          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
11327          break;
11328       }
11329
11330       ret = ROK;
11331       break;
11332
11333    }
11334    FreeUeContextModicationRequest(f1apMsg);
11335    return ret;
11336 }
11337
11338 /*****************************************************************i
11339  *
11340 * @brief Free memory allocated for UE Context Release Command
11341 *
11342 * @details
11343 *
11344 *    Function : FreeUeContextReleaseCommand
11345 *
11346 *    Functionality:
11347 *         - Free memory allocated for UE Context Release Command
11348 *
11349 * @params[in] F1AP_PDU_t *f1apMsg
11350 * @return void
11351 *
11352 * *************************************************************/
11353 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
11354 {
11355    uint8_t ieIdx;
11356    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
11357
11358    if(f1apMsg)
11359    {
11360       if(f1apMsg->choice.initiatingMessage)
11361       {
11362          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11363          if(ueReleaseCommand->protocolIEs.list.array)
11364          {
11365             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
11366             {
11367                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11368             }
11369             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
11370          }
11371          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11372       }
11373       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11374    }
11375 }
11376 /*******************************************************************
11377  *
11378  * @brief Builds the Ue Context Release Command
11379  *
11380  * @details
11381 *
11382 *    Function : BuildAndSendUeContextReleaseCommand
11383 *
11384 *    Functionality: Constructs the Ue Context Release Command
11385 *
11386 * @params[in]
11387 *
11388 * @return ROK     - success
11389 *         RFAILED - failure
11390 *
11391 * ****************************************************************/
11392 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
11393 {
11394    bool       memAllocFailed = false;
11395    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
11396    DuDb *duDb;
11397    CuUeCb *ueCb;
11398    F1AP_PDU_t *f1apMsg = NULLP;
11399    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
11400
11401    asn_enc_rval_t         encRetVal;
11402    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
11403
11404    while(true)
11405    {
11406       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11407       if(f1apMsg == NULLP)
11408       {
11409          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
11410          break;
11411       }
11412
11413       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11414
11415       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11416       if(f1apMsg->choice.initiatingMessage == NULLP)
11417       {
11418          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
11419          break;
11420       }
11421       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
11422       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11423       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
11424
11425       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11426
11427       SEARCH_DU_DB(duIdx, duId, duDb);
11428       ueCb = &duDb->ueCb[duUeF1apId-1];
11429       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11430          elementCnt = 3;
11431       else
11432          elementCnt = 4;
11433
11434       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
11435       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
11436
11437       /* Initialize the UE context modification members */
11438       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
11439       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
11440       {
11441          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
11442          break;
11443       }
11444
11445       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11446       {
11447          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11448          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
11449          {
11450             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
11451             memAllocFailed = true;
11452             break;
11453          }
11454       }
11455
11456       if(memAllocFailed == true)
11457       {
11458          break;
11459       }
11460
11461       ieIdx=0;
11462       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11463       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11464       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11465       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
11466       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
11467
11468       ieIdx++;
11469       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11470       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11471       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11472       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
11473       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
11474
11475       /* Cause of UE context release */
11476       ieIdx++;
11477       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
11478       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11479       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11480                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
11481       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11482       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
11483                                                                                                      CauseRadioNetwork_normal_release;
11484       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11485       {
11486          /* RRC Container for RRC release */
11487          ieIdx++;
11488          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11489          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11490          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11491                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
11492          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
11493          bufLen =7;
11494          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
11495          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
11496                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
11497          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
11498          {
11499             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
11500             break;
11501          }
11502          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
11503          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
11504       }
11505       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11506
11507       /* Encode the UE Context Release Command type as APER */
11508       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11509       encBufSize = 0;
11510       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11511             encBuf);
11512
11513       /* Encode results */
11514       if(encRetVal.encoded == ENCODE_FAIL)
11515       {
11516          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11517                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11518          break;
11519       }
11520       else
11521       {
11522          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
11523          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11524          {
11525             DU_LOG("%x",encBuf[ieIdx]);
11526          }
11527       }
11528
11529       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11530       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11531       {
11532          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11533          break;
11534       }
11535
11536       ret = ROK;
11537       break;
11538
11539    }
11540    FreeUeContextReleaseCommand(f1apMsg);
11541    return ret;
11542 }
11543 /*******************************************************************
11544 *
11545 * @brief process Ue context release request
11546 *
11547 * @details
11548 *
11549 *    Function : procUeContextReleaseReq
11550 *
11551 *    Functionality:
11552 *         - process Ue context release request
11553 *
11554 * @params[in] F1AP_PDU_t *f1apMsg
11555 * @return ROK     - success
11556 *         RFAILED - failure
11557 *
11558 * ****************************************************************/
11559 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11560 {
11561    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11562
11563    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11564    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11565
11566    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11567    {
11568       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11569       {
11570          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11571             {
11572                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11573                break;
11574             }
11575          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11576             {
11577                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11578                break;
11579             }
11580          default:
11581               break;
11582       }
11583    }
11584
11585    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11586    {
11587       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11588       return RFAILED;
11589    }
11590    return ROK;
11591 }
11592 /*******************************************************************
11593 *
11594 * @brief processing of Gnb-DU config update
11595 *
11596 * @details
11597 *
11598 *    Function : procGnbDuUpdate
11599 *
11600 *    Functionality:
11601 *         - processing of Gnb-DU config update
11602 *
11603 * @params[in] F1AP_PDU_t *f1apMsg
11604 * @return ROK     - success
11605 *         RFAILED - failure
11606 *
11607 * ****************************************************************/
11608 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11609 {
11610    bool cellToBeDelete = false;
11611    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11612    uint16_t nrCellId;
11613    DuDb *duDb;
11614    CuCellCb *cellCb;
11615    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11616
11617    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11618    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11619    {
11620       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11621       {
11622          case ProtocolIE_ID_id_TransactionID:
11623             break;
11624          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11625             break;
11626          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11627             {
11628                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11629                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11630                   Served_Cells_To_Delete_List.list.array[0];
11631                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11632                cellToBeDelete = true;
11633                break;
11634             }
11635          case ProtocolIE_ID_id_gNB_DU_ID:
11636             break;
11637       }
11638    }
11639    if(BuildAndSendDUUpdateAck(duId) != ROK)
11640    {
11641       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11642       return RFAILED;
11643    }
11644 #if 0
11645    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11646     * commented this trigger for now */
11647
11648    if(cellToBeDelete == false)
11649    {
11650       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11651       if(BuildAndSendF1ResetReq() != ROK)
11652       {
11653          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11654          return RFAILED;
11655       }
11656    }
11657 #endif
11658    if(cellToBeDelete == true)
11659    {
11660       SEARCH_DU_DB(duIdx, duId, duDb);
11661       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11662       if(cellCb->numUe == 0)
11663       {
11664          memset(cellCb, 0, sizeof(CuCellCb));
11665          duDb->numCells--;
11666       }
11667       else
11668          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11669    }
11670    return ROK;
11671 }
11672
11673 /*******************************************************************
11674 *
11675 * @brief storing slice list in CU database
11676 *
11677 * @details
11678 *
11679 *    Function : buildSliceList
11680 *
11681 *    Functionality:
11682 *         - storing slice list in CU database
11683 *
11684 * @params[in] SliceSupportList_t *sliceSupportList
11685 * @return ROK     - success
11686 *         RFAILED - failure
11687 *
11688 * ****************************************************************/
11689 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11690 {
11691    uint8_t sliceListIdx = 0;
11692
11693    if(sliceSupportList)
11694    {
11695       if(sliceSupportList->list.array)
11696       {
11697          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11698          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11699          {
11700             if(sliceSupportList->list.array[sliceListIdx])
11701             {
11702                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11703                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11704                {
11705                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11706                    return RFAILED;
11707                }
11708                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11709                {
11710                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11711                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11712                }
11713                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11714                {
11715                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11716                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11717                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11718                }
11719             }
11720          }
11721       }
11722    }
11723    return ROK;
11724 }
11725
11726 /****************************************************************
11727  * @brief Function to process Srb Setup Mod List
11728  *
11729  * @details
11730  *
11731  *    Function : procSrbSetupModList
11732  *
11733  *    Functionality:
11734  *         - Function to process SRB Setup Mod List
11735  *
11736  * @params[in]
11737  * @return ROK     - success
11738  *         RFAILED - failure
11739  *
11740  * ****************************************************************/
11741 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11742 {
11743    uint8_t arrIdx = 0, srbIdx;
11744    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11745
11746    if(srbSetupList != NULLP)
11747    {
11748       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11749       {
11750          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11751          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11752          {
11753             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11754             {
11755                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11756                {
11757                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11758                   break;
11759                }
11760             }
11761          }
11762
11763       }
11764    }
11765    return ROK;
11766 }
11767
11768
11769 /****************************************************************
11770  * @brief Function to process Drb Setup Mod List
11771  *
11772  * @details
11773  *
11774  *    Function : procDrbSetupModList
11775  *
11776  *    Functionality:
11777  *         - Function to process DRB Setup Mod List
11778  *
11779  * @params[in]
11780  * @return ROK     - success
11781  *         RFAILED - failure
11782  *
11783  * ****************************************************************/
11784 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11785 {
11786    uint8_t arrIdx = 0, drbIdx;
11787    uint32_t teId = 0;
11788    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11789
11790    if(drbSetupList != NULLP)
11791    {
11792       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11793       {
11794          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11795          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11796          {
11797             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11798             {
11799                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11800                {
11801                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11802                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11803                   break;
11804                }
11805             }
11806
11807             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11808             {
11809             /* extracting teId */
11810             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11811             if(teId > 0)
11812             {
11813               if(addDrbTunnels(duId, teId)== ROK)
11814               {
11815                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11816               }
11817             }
11818             else
11819                return RFAILED;
11820             }
11821          }
11822       }
11823    }
11824    return ROK;
11825 }
11826
11827 /*******************************************************************
11828 *
11829 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11830 *
11831 * @details
11832 *
11833 *    Function : procServedCellPlmnList
11834 *
11835 *    Functionality:
11836 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11837 *         SNSSAI list
11838 *
11839 * @params[in] F1AP_PDU_t *f1apMsg
11840 * @return ROK     - success
11841 *         RFAILED - failure
11842 *
11843 * ****************************************************************/
11844 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11845 {
11846    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11847    ProtocolExtensionContainer_4624P3_t **ieExtend;
11848
11849    if(srvPlmn->list.array)
11850    {
11851       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11852       {
11853          if(srvPlmn->list.array[srvPlmnIdx])
11854          {
11855             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11856             if(*ieExtend)
11857             {
11858                if((*ieExtend)->list.array)
11859                {
11860                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11861                   {
11862                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11863                      {
11864                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11865                         {
11866                            case ProtocolIE_ID_id_TAISliceSupportList:
11867                               {
11868                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11869                                           extensionValue.choice.SliceSupportList) != ROK)
11870                                  {
11871                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11872                                     return RFAILED;
11873                                  }
11874                               }
11875                         }
11876                      }
11877                   }
11878                }
11879             }
11880          }
11881       }
11882    }
11883    return ROK;
11884 }
11885
11886 /****************************************************************
11887  * @brief Function to process Ue Context Modification Response
11888  *
11889  * @details
11890  *
11891  *    Function : procUeContextModificationResponse
11892  *
11893  *    Functionality:
11894  *         - Function to process Ue Context Modification Response
11895  *
11896  * @params[in]
11897  * @return ROK     - success
11898  *         RFAILED - failure
11899  *
11900  * ****************************************************************/
11901 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11902 {
11903    uint8_t idx=0, duIdx=0;
11904    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11905    DuDb *duDb = NULLP;
11906    CuUeCb *ueCb = NULLP;
11907    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11908
11909    SEARCH_DU_DB(duIdx, duId, duDb);
11910    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11911
11912    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11913    {
11914       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11915       {
11916           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11917              {
11918                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11919                 break;
11920              }
11921           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11922              {
11923                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11924                 ueCb = &duDb->ueCb[duUeF1apId-1];
11925                 break;
11926              }
11927           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11928              {
11929                 /* Adding Tunnels for successful DRB */
11930                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11931                 break;
11932
11933              }
11934              case ProtocolIE_ID_id_DRBs_Modified_List:
11935              {
11936                 DU_LOG("\nINFO  -->  Received DRBs Modified List");
11937                 break;
11938              }
11939           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11940              {
11941                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11942                 break;
11943              }
11944          case ProtocolIE_ID_id_DUtoCURRCInformation:
11945              {
11946                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11947                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11948                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11949                 {
11950                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11951                    return RFAILED;
11952                 }
11953                 break;
11954              }
11955
11956       }
11957    }
11958
11959    /* If UE is in handover and UE context is not yet created at target DU, then send
11960     * UE context setup request to target DU */
11961    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11962    {
11963       uint8_t ueIdx = 0;
11964       DuDb *tgtDuDb = NULLP;
11965       CuUeCb *ueCbInTgtDu = NULLP;
11966
11967       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11968       if(tgtDuDb)
11969       {
11970          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11971           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11972           * DB */
11973          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11974          {
11975             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11976             {
11977                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11978                break;
11979             }
11980          }
11981
11982          /* If UE context is not found in Target DU DU, send UE context setup
11983           * request */
11984          if(ueCbInTgtDu == NULLP)
11985          {
11986             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
11987             {
11988                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11989                return RFAILED;
11990             }
11991          }
11992       }
11993    }
11994
11995 #ifdef START_DL_UL_DATA
11996    startDlData();
11997 #endif
11998
11999    return ROK;
12000 }
12001
12002 /*******************************************************************
12003 *
12004 * @brief processing of F1 setup request
12005 *
12006 * @details
12007 *
12008 *    Function : procF1SetupReq
12009 *
12010 *    Functionality:
12011 *         - processing of  F1 setup request
12012 *
12013 * @params[in] F1AP_PDU_t *f1apMsg
12014 * @return ROK     - success
12015 *         RFAILED - failure
12016 *
12017 * ****************************************************************/
12018 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
12019 {
12020    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
12021    uint32_t duId = 0;
12022    uint64_t nrCellId = 0;
12023    DuDb     *duDb = NULLP;
12024    CuCellCb *cellCb = NULLP;
12025    BIT_STRING_t nrcellIdentity;
12026    F1SetupRequest_t *f1SetupReq = NULLP;
12027    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
12028    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
12029
12030    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
12031    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
12032    {
12033       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
12034       {
12035          case ProtocolIE_ID_id_gNB_DU_ID:
12036            {
12037               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
12038               SEARCH_DU_DB(duIdx, duId, duDb);
12039               if(duDb == NULLP)
12040               {
12041                  duDb = &cuCb.duInfo[cuCb.numDu];
12042                  cuCb.numDu++;
12043               }
12044               memset(duDb, 0, sizeof(DuDb));
12045               duDb->duId = duId;
12046               *destDuId = duId;
12047               break;
12048            }
12049          case ProtocolIE_ID_id_gNB_DU_Name:
12050            {
12051               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
12052               break;
12053            }
12054          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
12055            {
12056                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
12057                if(duServedCell->list.array)
12058                {
12059                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
12060                   {
12061                      if(duServedCell->list.array[plmnidx])
12062                      {
12063                         switch(duServedCell->list.array[plmnidx]->id)
12064                         {
12065                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
12066                            {
12067                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
12068                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
12069                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
12070
12071                               bitStringToInt(&nrcellIdentity, &nrCellId);
12072                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
12073                               if(cellCb == NULLP)
12074                               {
12075                                  cellCb = &duDb->cellCb[duDb->numCells];
12076                                  memset(cellCb, 0, sizeof(CuCellCb));
12077                                  cellCb->nrCellId = nrCellId;
12078                                  cellCb->cellStatus = CELL_ACTIVE;
12079                                  duDb->numCells++;
12080                               }
12081                            }
12082                         }
12083                      }
12084                   }
12085                }
12086            }
12087       }
12088    }
12089    if(ret == ROK)
12090    {
12091       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
12092    }
12093    else
12094    {
12095        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
12096    }
12097 }
12098
12099 /****************************************************************
12100 *
12101 * @brief processing of UE Context Release Complete
12102 *
12103 * @details
12104 *
12105 *    Function : procUeContextReleaseComplete
12106 *
12107 *    Functionality:
12108 *         - processing of UE Context Release Complete
12109 *
12110 * @params[in] F1AP_PDU_t *f1apMsg
12111 * @return ROK     - success
12112 *         RFAILED - failure
12113 *
12114 * ****************************************************************/
12115 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
12116 {
12117    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
12118    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
12119    DuDb *duDb = NULLP;
12120    CuUeCb *ueCb = NULLP;
12121    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12122
12123    SEARCH_DU_DB(duIdx, duId, duDb);
12124    if(!duDb)
12125    {
12126       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
12127       return;
12128    }
12129
12130    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12131    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
12132    {
12133       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
12134       {
12135          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12136             {
12137                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12138                break;
12139             }
12140          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12141             {
12142                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12143                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
12144                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
12145                {
12146                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
12147                   {
12148                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
12149                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
12150                      {
12151                         for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
12152                         {
12153                            deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
12154                         }
12155                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
12156                         ueCb->cellCb->numUe--;
12157                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
12158                         {
12159                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
12160                            duDb->numCells--;
12161                         }
12162                         break;
12163                      }
12164                   }
12165                }
12166                memset(ueCb, 0, sizeof(CuUeCb));
12167                duDb->numUe--;
12168                break;
12169             }
12170       }
12171    }
12172 }
12173
12174 /*******************************************************************
12175  *
12176  * @brief Builds the Paging cell list
12177  *
12178  * @details
12179  *
12180  *    Function : BuildPagingCellList
12181  *
12182  *    Functionality: Build the paging cell list
12183  *
12184  * @params[in] PagingCell_list_t  *pagingCelllist,
12185  *
12186  * @return ROK     - success
12187  *         RFAILED - failure
12188  *
12189  * ****************************************************************/
12190 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
12191 {
12192    uint8_t cellIdx =0;
12193    PagingCell_ItemIEs_t *pagingCellItemIes;
12194    PagingCell_Item_t *pagingCellItem;
12195
12196    pagingCelllist->list.count = numCells;
12197    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
12198    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
12199    if(pagingCelllist->list.array == NULLP)
12200    {
12201       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12202       return RFAILED;
12203    }
12204
12205    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12206    {
12207       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12208       if(pagingCelllist->list.array[cellIdx] == NULLP)
12209       {
12210          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12211          return RFAILED;
12212       }
12213    }
12214
12215    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12216    {
12217       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12218       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
12219       pagingCellItemIes->criticality = Criticality_ignore;
12220       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
12221       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12222
12223       /* Fill NrCgi Information */
12224       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
12225    }
12226
12227    return ROK;
12228 }
12229
12230 /*******************************************************************
12231  *
12232  * @brief Deallocation of memory allocated in paging msg
12233  *
12234  * @details
12235  *
12236  *    Function :FreePagingMsg
12237  *
12238  *    Functionality: Deallocation of memory allocated in paging msg
12239  *
12240  * @params[in] F1AP_PDU_t *f1apMsg
12241  *
12242  * @return void
12243  *
12244  * ****************************************************************/
12245 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
12246 {
12247    uint8_t ieIdx, cellIdx;
12248    Paging_t   *paging;
12249    PagingCell_ItemIEs_t *pagingCellItemIes;
12250    PagingCell_Item_t *pagingCellItem;
12251    PagingCell_list_t  *pagingCelllist;
12252
12253    if(f1apMsg)
12254    {
12255       if(f1apMsg->choice.initiatingMessage)
12256       {
12257          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12258          if(paging->protocolIEs.list.array)
12259          {
12260             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
12261             {
12262                if(paging->protocolIEs.list.array[ieIdx])
12263                {
12264                   switch(paging->protocolIEs.list.array[ieIdx]->id)
12265                   {
12266                      case ProtocolIE_ID_id_UEIdentityIndexValue:
12267                      {
12268                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12269                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12270                         break;
12271                      }
12272
12273                      case ProtocolIE_ID_id_PagingIdentity:
12274                      {
12275                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
12276                         {
12277                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12278                            {
12279                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
12280                               {
12281                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12282                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12283                               }
12284                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
12285                                 sizeof(struct CNUEPagingIdentity));
12286                            }
12287                         }
12288                         break;
12289                      }
12290
12291                      case ProtocolIE_ID_id_PagingCell_List:
12292                      {
12293                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
12294                         if(pagingCelllist->list.array)
12295                         {
12296                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12297                            {
12298                               if(pagingCelllist->list.array[cellIdx])
12299                               {
12300                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12301                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
12302                                   {
12303                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12304                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
12305                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
12306                                   }
12307                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12308                               }
12309                            }
12310                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
12311                         }
12312                         break;
12313                      }
12314                   }
12315                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12316                }
12317             }
12318             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12319          }
12320          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12321       }
12322       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12323    }
12324 }
12325 /*******************************************************************
12326  *
12327  * @brief Builds and sends the paging message if UE is in idle mode
12328  *
12329  * @details
12330  *
12331  *    Function : BuildAndSendPagingMsg
12332  *
12333  *    Functionality: Builds and sends the paging message
12334  *
12335  * @params[in] uint32_t duId, uint8_t gsTmsi
12336  *
12337  * @return ROK     - success
12338  *         RFAILED - failure
12339  *
12340  * ****************************************************************/
12341 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
12342 {
12343    bool       memAllocFailed = false;
12344    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
12345    uint16_t   ueId = 0, duIdx = 0;
12346
12347    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
12348     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
12349    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
12350    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
12351
12352    F1AP_PDU_t *f1apMsg = NULLP;
12353    Paging_t   *paging = NULLP;
12354    DuDb       *duDb;
12355    asn_enc_rval_t         encRetVal;
12356
12357    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
12358
12359    SEARCH_DU_DB(duIdx, duId, duDb);
12360    if(duDb == NULLP)
12361    {
12362       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
12363       return ret;
12364    }
12365    if(duDb->numCells == 0)
12366    {
12367       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): No CELL is UP!");
12368       return ret;
12369    }
12370
12371    while(true)
12372    {
12373       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12374       if(f1apMsg == NULLP)
12375       {
12376          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
12377          break;
12378       }
12379
12380       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
12381
12382       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12383       if(f1apMsg->choice.initiatingMessage == NULLP)
12384       {
12385          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
12386          break;
12387       }
12388       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
12389       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12390       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
12391
12392       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12393
12394       elementCnt = 5;
12395       paging->protocolIEs.list.count = elementCnt;
12396       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
12397
12398       /* Initialize the Paging Message members */
12399       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12400       if(paging->protocolIEs.list.array == NULLP)
12401       {
12402          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
12403          break;
12404       }
12405
12406       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12407       {
12408          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12409          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
12410          {
12411             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12412             memAllocFailed = true;
12413             break;
12414          }
12415       }
12416
12417       if(memAllocFailed == true)
12418       {
12419          break;
12420       }
12421
12422       /* UE Identity Index Value */
12423       ieIdx=0;
12424       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
12425       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12426       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
12427       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
12428       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
12429       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12430             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12431       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
12432       {
12433          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12434          break;
12435       }
12436
12437       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
12438       ueId = gsTmsi % 1024;
12439       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
12440
12441       /* Paging Identity */
12442       ieIdx++;
12443       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
12444       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12445       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
12446       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
12447                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
12448       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
12449             sizeof(struct CNUEPagingIdentity));
12450       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12451       {
12452          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12453          break;
12454       }
12455
12456       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
12457                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
12458
12459       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
12460       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12461             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12462       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
12463       {
12464          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12465          break;
12466       }
12467
12468       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
12469             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
12470
12471       /* Paging Drx */
12472       ieIdx++;
12473       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
12474       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12475       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
12476       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
12477
12478       /* Paging Priority */
12479       ieIdx++;
12480       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
12481       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12482       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
12483       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
12484
12485       /* Paging Cell List */
12486       ieIdx++;
12487       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
12488       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12489       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
12490       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
12491       {
12492          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
12493          break;
12494       }
12495
12496       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12497
12498       /* Encode the UE Context Release Command type as APER */
12499       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12500       encBufSize = 0;
12501       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12502             encBuf);
12503
12504       /* Encode results */
12505       if(encRetVal.encoded == ENCODE_FAIL)
12506       {
12507          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
12508                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12509          break;
12510       }
12511       else
12512       {
12513          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
12514          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12515          {
12516             DU_LOG("%x",encBuf[ieIdx]);
12517          }
12518       }
12519
12520       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
12521       {
12522          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
12523          break;
12524       }
12525
12526       ret = ROK;
12527       break;
12528
12529    }
12530
12531    FreePagingMsg(f1apMsg);
12532    return ret;
12533 }
12534
12535 /*******************************************************************
12536  *
12537  * @brief Handles received F1AP message and sends back response
12538  *
12539  * @details
12540  *
12541  *    Function : F1APMsgHdlr
12542  *
12543  *    Functionality:
12544  *         - Decodes received F1AP control message
12545  *         - Prepares response message, encodes and sends to SCTP
12546  *
12547  * @params[in]
12548  * @return ROK     - success
12549  *         RFAILED - failure
12550  *
12551  * ****************************************************************/
12552 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12553 {
12554    int i;
12555    char *recvBuf;
12556    MsgLen copyCnt;
12557    MsgLen recvBufLen;
12558    F1AP_PDU_t *f1apMsg = NULLP;
12559    asn_dec_rval_t rval; /* Decoder return value */
12560    F1AP_PDU_t f1apasnmsg ;
12561
12562    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12563    ODU_PRINT_MSG(mBuf, 0,0);
12564
12565    /* Copy mBuf into char array to decode it */
12566    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12567    CU_ALLOC(recvBuf, (Size)recvBufLen);
12568
12569    if(recvBuf == NULLP)
12570    {
12571       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12572       return;
12573    }
12574    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12575    {
12576       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12577       return;
12578    }
12579
12580    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12581    for(i=0; i< recvBufLen; i++)
12582    {
12583       DU_LOG("%x",recvBuf[i]);
12584    }
12585
12586    /* Decoding flat buffer into F1AP messsage */
12587    f1apMsg = &f1apasnmsg;
12588    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12589
12590    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12591    CU_FREE(recvBuf, (Size)recvBufLen);
12592
12593    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12594    {
12595       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12596       return;
12597    }
12598    DU_LOG("\n");
12599    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12600
12601    switch(f1apMsg->present)
12602    {
12603       case F1AP_PDU_PR_initiatingMessage:
12604          {
12605             switch(f1apMsg->choice.initiatingMessage->value.present)
12606             {
12607                case InitiatingMessage__value_PR_Reset:
12608                   {
12609                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12610                      BuildAndSendF1ResetAck();
12611                      break;
12612                   }
12613
12614                case InitiatingMessage__value_PR_F1SetupRequest:
12615                   {
12616                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12617                      procF1SetupReq(duId, f1apMsg);
12618                      break;
12619                   }
12620
12621                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12622                   {
12623                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12624                      procGnbDuUpdate(*duId, f1apMsg);
12625                      break;
12626                   }
12627                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12628                   {
12629                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12630                      procInitULRRCMsg(*duId, f1apMsg);
12631                      break;
12632                   }
12633                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12634                   {
12635                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12636                      procUlRrcMsg(*duId, f1apMsg);
12637                      break;
12638                   }
12639
12640                case InitiatingMessage__value_PR_RRCDeliveryReport:
12641                   {
12642                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12643                      break;
12644                   }
12645                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12646                   {
12647                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12648                      procUeContextReleaseReq(*duId, f1apMsg);
12649                      break;
12650                   }
12651                default:
12652                   {
12653                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12654                            f1apMsg->choice.initiatingMessage->value.present);
12655                      return;
12656                   }
12657             }/* End of switch(initiatingMessage) */
12658             break;
12659          }
12660
12661       case F1AP_PDU_PR_successfulOutcome:
12662          {
12663             switch(f1apMsg->choice.successfulOutcome->value.present)
12664             {
12665                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12666                   {
12667                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12668                      break;
12669                   }
12670                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12671                   {
12672                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12673                      procUeContextSetupResponse(*duId, f1apMsg);
12674                      break;
12675                   }
12676                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12677                   {
12678                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12679                      procUeContextModificationResponse(*duId, f1apMsg);
12680                      break;
12681                   }
12682                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12683                   {
12684                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12685                       procUeContextReleaseComplete(*duId, f1apMsg);
12686                       break;
12687                   }
12688                default:
12689                   {
12690                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12691                            f1apMsg->choice.successfulOutcome->value.present);
12692                      return;
12693                   }
12694             }/* End of switch(successfulOutcome) */
12695             break;
12696          }
12697       default:
12698          {
12699             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12700             return;
12701          }
12702    }/* End of switch(f1apMsg->present) */
12703
12704 } /* End of F1APMsgHdlr */
12705
12706 /**********************************************************************
12707   End of file
12708  **********************************************************************/