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