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    /* UE Capabulity RAT Container List */
9028    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9029    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
9030    {
9031       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
9032       return RFAILED;
9033    }
9034    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
9035
9036 #if 0
9037
9038    /* Commenting this because:
9039     * CUToDURRCInformation->MeasConfig contains measurement gap configurations.
9040     * Howeever measurement gap is not supported in our code. Measurement Gap will
9041     * be required if we want to support inter-RAT handover or handover to
9042     * neighbouring cells operating on a different frequency than serving cell.
9043     *
9044     * In case we plan to use this IE in future, following fixes are required:
9045     * As of now, we are filling MeasurementTimingConfigurationRrc_t into rrcMsg->measConfig.
9046     * This is incorrect. We must fill MeasConfigRrc_t in rrcMsg->measConfig.
9047     * MeasurementTimingConfigurationRrc_t should be filled in
9048     * rrcMsg->iE_Extensions->MeasurementTimingConfiguration, if required.
9049     */
9050
9051    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
9052    if(!rrcMsg->measConfig)
9053    {
9054       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
9055       return RFAILED;
9056    }
9057    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
9058 #endif
9059
9060    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9061    {
9062       /* IE extensions */
9063       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9064       if(rrcMsg->iE_Extensions)
9065       {
9066          elementCnt = 1;
9067          rrcMsg->iE_Extensions->list.count = elementCnt;
9068          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
9069
9070          /* Initialize the CUtoDURRCInformation_ExtIEs */
9071          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9072
9073          if(rrcMsg->iE_Extensions->list.array == NULLP)
9074          {
9075             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
9076             ret = RFAILED;
9077          }
9078
9079          for(idx=0; idx<elementCnt; idx++)
9080          {
9081             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
9082             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
9083             {
9084                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
9085                ret = RFAILED;
9086             }
9087          }
9088
9089          idx = 0;
9090 #if 0
9091          /* Cell Group Configuration */
9092          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
9093          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9094          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
9095                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
9096          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
9097          idx++;
9098 #endif
9099          /* Handover Preparation Information */
9100          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
9101          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9102          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
9103                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
9104          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
9105       }
9106    }
9107    return ret;
9108 }
9109 /*******************************************************************
9110  *
9111  * @brief Build the drx cycle
9112  *
9113  * @details
9114  *
9115  *    Function : BuildDrxCycle
9116  *
9117  *    Functionality: Build drx cycle IE
9118  *
9119  * @params[in] pointer to DRXCycle_t
9120  *
9121  * @return ROK     - success
9122  *         RFAILED - failure
9123  *
9124  ******************************************************************/
9125 uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
9126 {
9127    drxCycle->longDRXCycleLength = LongDRXCycleLength_ms80;
9128    CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
9129    if(!drxCycle->shortDRXCycleLength)
9130    {
9131       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleLength");
9132       return RFAILED;
9133    }
9134    *(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
9135
9136    CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
9137    if(!drxCycle->shortDRXCycleTimer)
9138    {
9139       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleTimer");
9140       return RFAILED;
9141    }
9142    *(drxCycle->shortDRXCycleTimer) = 4;
9143    return ROK;
9144 }
9145 /*******************************************************************
9146  *
9147  * @brief Free CuToDuContainer
9148  *
9149  * @details
9150  *
9151  *    Function : FreeCuToDuInfo
9152  *
9153  *    Functionality: Free CuToDuContainer
9154  *
9155  * @params[in] pointer to CUtoDURRCInformation_t
9156  *
9157  * @return ROK     - success
9158  *         RFAILED - failure
9159  *
9160  ******************************************************************/
9161
9162 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9163 {
9164    uint8_t idx, idx2;
9165
9166    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9167    {
9168       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9169          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
9170       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9171    }
9172    if(rrcMsg->iE_Extensions)
9173    {
9174       if(rrcMsg->iE_Extensions->list.array)
9175       {
9176          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
9177          {
9178             if(rrcMsg->iE_Extensions->list.array[idx])
9179             {
9180                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
9181                {
9182                   case ProtocolIE_ID_id_CellGroupConfig:
9183                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9184                      {
9185                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
9186                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
9187
9188                      }
9189                      break;
9190                   default:
9191                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9192                            rrcMsg->iE_Extensions->list.array[idx]->id);
9193                      break;
9194                }
9195             }
9196             break;
9197          }
9198          for(idx2 = 0; idx2 < idx; idx2++)
9199          {
9200             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
9201          }
9202          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9203
9204       }
9205
9206       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9207    }
9208 }
9209 /*******************************************************************
9210  *
9211  * @brief Builds and sends the UE Setup Request
9212  *
9213  * @details
9214  *
9215  *    Function : BuildAndSendUeContextSetupReq
9216  *
9217  *    Functionality: Constructs the UE Setup Request and sends
9218  *                   it to the CU through SCTP.
9219  *
9220  * @params[in]
9221  *
9222  * @return ROK     - success
9223  *         RFAILED - failure
9224  *
9225  * ****************************************************************/
9226 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
9227 {
9228    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
9229    uint8_t   ret= RFAILED, ret1;
9230    uint8_t   elementCnt;
9231    uint8_t   idx, idx1, bufLen, duIdx;
9232    uint32_t  spCellId;
9233    uint32_t  targetDuId;
9234    DuDb      *targetDuDb = NULLP;
9235    F1AP_PDU_t           *f1apMsg = NULLP;
9236    UEContextSetupRequest_t *ueSetReq = NULLP;
9237    asn_enc_rval_t encRetVal;        /* Encoder return value */
9238    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9239
9240    while(true)
9241    {
9242       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
9243
9244       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9245       if(f1apMsg == NULLP)
9246       {
9247          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9248          break;
9249       }
9250
9251       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9252       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9253       if(f1apMsg->choice.initiatingMessage == NULLP)
9254       {
9255          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
9256          break;
9257       }
9258
9259       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
9260       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9261       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
9262
9263       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9264
9265       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9266          elementCnt = 7;
9267       else
9268       {
9269 #ifdef NR_DRX
9270          elementCnt = 12;
9271 #else
9272          elementCnt = 11;
9273 #endif
9274       }
9275       ueSetReq->protocolIEs.list.count = elementCnt;
9276       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
9277
9278       /* Initialize the UESetup members */
9279       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
9280
9281       if(ueSetReq->protocolIEs.list.array == NULLP)
9282       {
9283          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
9284          break;
9285       }
9286
9287       for(idx1=0; idx1<elementCnt; idx1++)
9288       {
9289          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
9290          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
9291          {
9292             break;
9293          }
9294       }
9295
9296       idx = 0;
9297
9298       /*GNB CU UE F1AP ID*/
9299       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9300       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9301       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
9302       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
9303
9304       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9305       {
9306          /*GNB DU UE F1AP ID*/
9307          idx++;
9308          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9309          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9310          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
9311          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
9312       }
9313
9314       /*Special Cell ID*/
9315       idx++;
9316       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
9317       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9318       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
9319
9320       /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
9321       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9322       {
9323          if(ueCb->hoInfo.HOType == Inter_DU_HO)
9324             targetDuId = ueCb->hoInfo.tgtNodeId;
9325          else
9326             targetDuId = duId;
9327
9328          SEARCH_DU_DB(duIdx, targetDuId, targetDuDb);
9329          /* Since we are supporting only one cell per DU, accessing 0th index to
9330           * get target cell info */
9331          spCellId = targetDuDb->cellCb[0].nrCellId;
9332       }
9333       else
9334          spCellId = ueCb->cellCb->nrCellId;
9335
9336       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
9337       if(Nrcgiret != ROK)
9338       {
9339          break;
9340       }
9341
9342       /*Served Cell Index*/
9343       idx++;
9344       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9345       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9346       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9347       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9348
9349       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9350       {
9351          /*CellULConfigured*/
9352          idx++;
9353          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9354          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9355          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9356          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9357       }
9358
9359       /*CUtoDURRCContainer*/
9360       idx++;
9361       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9362       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9363       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9364       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9365       {
9366          break;
9367       }
9368
9369       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9370       {
9371          /*Drx cycle*/
9372 #ifdef NR_DRX
9373          idx++;
9374          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_DRXCycle;
9375          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9376          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
9377          if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
9378          {
9379             DU_LOG("\nERROR  -->  F1AP : Failed to build drx cycle");
9380             break;
9381          }
9382 #endif
9383          /*Special Cells to be SetupList*/
9384          idx++;
9385          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9386          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9387          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9388          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9389          if(SplCellListret != ROK)
9390          {
9391             break;
9392          }
9393       }
9394
9395       /*SRBs To Be Setup List*/
9396       idx++;
9397       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9398       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9399       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9400       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9401       if(SrbSetupret != ROK)
9402       {
9403          break;
9404       }
9405
9406       /*DRBs to Be Setup List*/
9407       idx++;
9408       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9409       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9410       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9411       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9412       if(ret1 != ROK)
9413       {
9414          break;
9415       }
9416
9417       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9418       {
9419          /* RRC delivery status request */
9420          idx++;
9421          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9422          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9423          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9424          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9425       }
9426
9427       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9428       idx++;
9429       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9430       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9431       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9432
9433       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9434       bufLen = 4;
9435       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9436       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9437             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9438       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9439       {
9440          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9441          break;
9442       }
9443       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9444       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9445
9446       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9447
9448       /* Encode the F1SetupRequest type as APER */
9449       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9450       encBufSize = 0;
9451       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9452
9453       /* Encode results */
9454       if(encRetVal.encoded == ENCODE_FAIL)
9455       {
9456          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9457                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9458          break;
9459       }
9460       else
9461       {
9462          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9463          for(int i=0; i< encBufSize; i++)
9464          {
9465             DU_LOG("%x",encBuf[i]);
9466          }
9467       }
9468
9469       /* Sending  msg  */
9470       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9471       {
9472          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9473          break;
9474       }
9475       ret = ROK;
9476       break;
9477    }
9478    FreeUeContextSetupReq(f1apMsg);
9479
9480    return ret;
9481 }/* End of BuildAndSendUeContextSetupReq*/
9482
9483 /**********************************************************************
9484  * @brief Function to extractTeId received in UE context setup Response
9485  *
9486  * @details
9487  *
9488  *    Function : extractTeId
9489  *
9490  *    Functionality:
9491  *         - Function to extract TeId
9492  *
9493  * @params[in]
9494  * @return ROK     - success
9495  *         RFAILED - failure
9496  *
9497  **********************************************************************/
9498 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9499 {
9500    uint8_t arrIdx = 0;
9501    uint32_t teId = 0;
9502    GTPTunnel_t *gtpDl = NULLP;
9503
9504    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9505    {
9506       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9507       {
9508          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9509          {
9510             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9511             if(gtpDl->gTP_TEID.size > 0)
9512             {
9513                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9514             }
9515             else
9516                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9517             return(teId);
9518          }
9519       }
9520    }
9521    return teId;
9522 }
9523
9524 /****************************************************************
9525  * @brief Function to add Drb tunnels
9526  *
9527  * @details
9528  *
9529  *    Function : addDrbTunnels
9530  *
9531  *    Functionality:
9532  *         - Function to add Drb tunnels
9533  *
9534  * @params[in]
9535  * @return ROK     - success
9536  *         RFAILED - failure
9537  *
9538  * ****************************************************************/
9539 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9540 {
9541    uint8_t ret = ROK;
9542    EgtpTnlEvt tnlEvt;
9543
9544    if(teId > MAX_TEID || teId < MIN_TEID)
9545    {
9546       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9547    }
9548    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9549    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9550    tnlEvt.lclTeid = teId;
9551    tnlEvt.remTeid = teId;
9552    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9553    if(ret != ROK)
9554    {
9555       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9556    }
9557    return ROK;
9558 }
9559
9560 /****************************************************************
9561  * @brief Function to process Drb Setup List
9562  *
9563  * @details
9564  *
9565  *    Function : procDrbSetupList
9566  *
9567  *    Functionality:
9568  *         - Function to process DRB Setup List
9569  *
9570  * @params[in]
9571  * @return ROK     - success
9572  *         RFAILED - failure
9573  *
9574  * ****************************************************************/
9575 uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
9576 {
9577    uint8_t arrIdx = 0, drbIdx = 0;
9578    uint32_t teId = 0;
9579    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9580
9581    if(drbSetupList != NULLP)
9582    {
9583       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9584       {
9585          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9586          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9587          {
9588             /* extracting teId */
9589             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9590             if(teId > 0)
9591             {
9592                if(addDrbTunnels(duId, teId)== ROK)
9593                {
9594                   DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9595                }
9596                /* As per Spec 38.473, in UE COntext Response, Tunnel information
9597                 * are sent to CU for setting up of Tunnels in DL direction.
9598                 * Search for DRB ID in CU databse */
9599                for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
9600                {
9601                   if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
9602                   {
9603                      fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
9604                      break;
9605                   }
9606                }
9607             }
9608             else
9609                return RFAILED;
9610          }
9611       }
9612    }
9613    return ROK;
9614 }
9615
9616 /****************************************************************
9617  * @brief Function to process Ue Context Setup Response
9618  *
9619  * @details
9620  *
9621  *    Function : procUeContextSetupResponse
9622  *
9623  *    Functionality:
9624  *         - Function to process Ue Context Setup Response
9625  *
9626  * @params[in]
9627  * @return ROK     - success
9628  *         RFAILED - failure
9629  *
9630  * ****************************************************************/
9631 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg, char *recvBuf, MsgLen recvBufLen)
9632 {
9633    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9634    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9635    DuDb *duDb = NULLP;
9636    CuUeCb *ueCb = NULLP;
9637    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9638    OCTET_STRING_t *duToCuRrcContainer;
9639
9640    SEARCH_DU_DB(duIdx, duId, duDb);
9641    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9642
9643    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9644    {
9645       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9646       {
9647           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9648              {
9649                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9650                break;
9651              }
9652           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9653              {
9654                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9655                 ueCb = &duDb->ueCb[duUeF1apId-1];
9656                 /* If ue context is not present in du db, then create UE context
9657                  * here. This flow is hit in case of UE handover where UE
9658                  * context is created before UE performs RACH on target DU */
9659                 if(ueCb->gnbDuUeF1apId == 0)
9660                 {
9661                    /* Creating UE context in target DU */
9662                    memset(ueCb, 0, sizeof(CuUeCb));
9663
9664                    /* Check if UE is under Inter-CU handover */
9665                    if(duDb->tempUeCtxtInHo && (duDb->tempUeCtxtInHo->gnbCuUeF1apId == cuUeF1apId))
9666                    {
9667                       memcpy(ueCb, duDb->tempUeCtxtInHo, sizeof(CuUeCb));
9668                       ueCb->gnbDuUeF1apId = duUeF1apId;
9669                       CU_FREE(duDb->tempUeCtxtInHo, sizeof(CuUeCb));
9670                    }
9671                    else
9672                    {
9673                       /* In case of Inter DU Handover */
9674                       ueCb->cellCb = &duDb->cellCb[0];
9675                       ueCb->gnbDuUeF1apId = duUeF1apId;
9676                       ueCb->gnbCuUeF1apId = cuUeF1apId;
9677                       ueCb->state = UE_HANDOVER_IN_PROGRESS;
9678                       ueCb->hoInfo.HOType = Inter_DU_HO;
9679                       ueCb->hoInfo.tgtNodeId = duId;
9680                    }
9681                    (duDb->numUe)++;
9682
9683                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9684                    ueCb->cellCb->numUe++;
9685                 }
9686                 break;
9687              }
9688           case ProtocolIE_ID_id_C_RNTI:
9689              {
9690                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9691                 break;
9692              }
9693           case ProtocolIE_ID_id_DRBs_Setup_List:
9694              {
9695                 /* Adding Tunnels for successful DRB */
9696                 procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9697                 break;
9698              }
9699          case ProtocolIE_ID_id_DUtoCURRCInformation:
9700              {
9701                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9702                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9703                    DUtoCURRCInformation.cellGroupConfig;
9704                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9705                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9706                 {
9707                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9708                    return RFAILED;
9709                 }
9710                 break;
9711              }
9712       }
9713    }
9714
9715    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9716    {
9717       ueCb->f1apMsgDb.dlRrcMsgCount++;
9718       rrcMsgType = setDlRRCMsgType(ueCb);
9719
9720       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9721       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9722       {
9723          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9724          return RFAILED;
9725       }
9726    }
9727    else
9728    {
9729       if(ueCb->hoInfo.HOType == Inter_DU_HO)
9730       {
9731          /* If the UE is in Inter-DU handover, UE context modification request is to be sent to
9732           * source DU once UE context setup response is received from target DU */
9733
9734          DuDb *srcDuDb = NULLP;
9735          CuUeCb *ueCbInSrcDu = NULLP;
9736
9737          /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9738           * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9739          for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9740          {
9741             /* UE context setup response is received from target DU. Search all
9742              * DUs to find source DU except this target DU Id.*/
9743             if(cuCb.duInfo[duIdx].duId != duId)
9744             {
9745                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9746                {
9747                   /* Check following:
9748                    * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9749                    * received in UE context setup response since CU UE F1AP ID does not
9750                    * change for UE in handover.
9751                    * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9752                    */
9753                   if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9754                         (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9755                   {
9756                      srcDuDb = &cuCb.duInfo[duIdx];
9757                      ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9758
9759                      /* Store source DU info in the new UE context created in
9760                       * tareget DU */
9761                      ueCb->hoInfo.srcNodeId = srcDuDb->duId;
9762
9763                      /* Copy the received container to UeCb */
9764                      memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9765
9766                      if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9767                      {
9768                         DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9769                         return RFAILED;
9770                      }
9771                      break;
9772                   }
9773                }
9774             }
9775             if(srcDuDb && ueCbInSrcDu)
9776                break;
9777          }
9778       }
9779       else if(ueCb->hoInfo.HOType == Xn_Based_Inter_CU_HO)
9780       {
9781          BuildAndSendHOReqAck(ueCb, duToCuRrcContainer->buf, duToCuRrcContainer->size);
9782       }
9783    }
9784
9785    return ROK;
9786 }
9787
9788 /****************************************************************
9789  * @brief Function to process Ul Rrc Msg received from DU
9790  *
9791  * @details
9792  *
9793  *    Function : procUlRrcMsg
9794  *
9795  *    Functionality:
9796  *         - Function to process Ul Rrc Msg received from DU
9797  *
9798  * @params[in]
9799  * @return ROK     - success
9800  *         RFAILED - failure
9801  *
9802  * ****************************************************************/
9803
9804 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9805 {
9806    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9807    uint8_t  *rrcContainer = NULLP;
9808    uint16_t rrcContLen = 0;
9809    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9810    DuDb     *duDb = NULLP;
9811    CuUeCb   *ueCb = NULLP;
9812    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9813
9814    ret = ROK;
9815    SEARCH_DU_DB(duIdx, duId, duDb);
9816    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9817
9818    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9819    {
9820       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9821       {
9822          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9823             {
9824                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9825                break;
9826             }
9827          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9828             {
9829                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9830                break;
9831             }
9832          case ProtocolIE_ID_id_SRBID:
9833             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9834             break;
9835
9836          case ProtocolIE_ID_id_RRCContainer:
9837             {
9838                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9839                CU_ALLOC(rrcContainer, rrcContLen);
9840                if(!rrcContainer)
9841                {
9842                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9843                   return RFAILED;
9844                }
9845                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9846
9847                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9848                {
9849                   if(duDb->ueCb[duUeF1apId-1].hoInfo.HOType == Inter_DU_HO)
9850                   {
9851                      uint8_t ueIdx = 0;
9852                      uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.srcNodeId;
9853                      DuDb *srcDuDb = NULLP;
9854
9855                      /* Release UE context in source DU because the UE is now
9856                       * attached to target DU */
9857                      SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9858                      for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9859                      {
9860                         if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9861                         {
9862                            ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9863                            if(ret != ROK)
9864                            {
9865                               DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9866                            }
9867                            break;
9868                         }
9869                      }
9870                   }
9871                   else
9872                   {
9873                      BuildAndSendUeContextRelease(&duDb->ueCb[duUeF1apId-1]);
9874                   }
9875
9876                   /* In target DU DB, mark UE as active and delete HO info */
9877                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9878                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9879                   return ret;
9880                }
9881                break;
9882             }
9883
9884          default:
9885             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9886             break;
9887       }
9888    }
9889
9890    if(srbId == 1)
9891    {
9892       ueCb = &duDb->ueCb[duUeF1apId-1];
9893       ueCb->f1apMsgDb.dlRrcMsgCount++;
9894       rrcMsgType = setDlRRCMsgType(ueCb);
9895       if(rrcMsgType == REGISTRATION_COMPLETE)
9896       {
9897          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9898          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9899       }
9900       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9901       {
9902          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9903          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9904       }
9905       else
9906       {
9907          /* In case rrcMsgType is RRC_SETUP_COMPLETE / NAS_AUTHENTICATION_RSP / NAS_SECURITY_MODE_COMPLETE / RRC_SECURITY_MODE_COMPLETE */
9908          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9909       }
9910    }
9911    return ret;
9912 }
9913
9914 /****************************************************************
9915  * @brief Build And Send F1ResetAck
9916  *
9917  * @details
9918  *
9919  *    Function : FreeF1ResetAck
9920  *
9921  *    Functionality:
9922  *         - Build And Send  F1ResetRSP
9923  *
9924  *  @params[in]
9925  * @return ROK     - success
9926  *         RFAILED - failure
9927  *
9928  * ****************************************************************/
9929 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9930 {
9931    uint8_t idx;
9932    ResetAcknowledge_t *f1ResetAck;
9933
9934    if(f1apMsg)
9935    {
9936       if(f1apMsg->choice.successfulOutcome)
9937       {
9938          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9939
9940          if(f1ResetAck->protocolIEs.list.array)
9941          {
9942             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9943             {
9944                if(f1ResetAck->protocolIEs.list.array[idx])
9945                {
9946                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9947                }
9948             }
9949             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9950          }
9951          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9952       }
9953       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9954    }
9955 }
9956
9957 /****************************************************************
9958  * @brief Build And Send F1ResetAck
9959  *
9960  * @details
9961  *
9962  *    Function : BuildAndSendF1ResetAck
9963  *
9964  *    Functionality:
9965  *         - Build And Send  F1ResetRSP
9966  *
9967  *  @params[in]
9968  * @return ROK     - success
9969  *         RFAILED - failure
9970  *
9971  * ****************************************************************/
9972
9973 uint8_t BuildAndSendF1ResetAck()
9974 {
9975    uint8_t                idx = 0;
9976    uint8_t                elementCnt = 0;
9977    uint8_t                ret = RFAILED;
9978    F1AP_PDU_t             *f1apMsg = NULL;
9979    ResetAcknowledge_t     *f1ResetAck = NULLP;
9980    asn_enc_rval_t         encRetVal;
9981    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9982
9983    do{
9984       /* Allocate the memory for F1ResetRequest_t */
9985       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9986       if(f1apMsg == NULLP)
9987       {
9988          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9989          break;
9990       }
9991
9992       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9993
9994       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9995       if(f1apMsg->choice.successfulOutcome == NULLP)
9996       {
9997          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9998          break;
9999       }
10000
10001       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
10002       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10003       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10004       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10005
10006       elementCnt = 1;
10007
10008       f1ResetAck->protocolIEs.list.count = elementCnt;
10009       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10010
10011       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10012       if(f1ResetAck->protocolIEs.list.array == NULLP)
10013       {
10014          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10015          break;
10016       }
10017
10018       for(idx=0; idx<elementCnt; idx++)
10019       {
10020          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10021          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10022          {
10023             break;
10024          }
10025       }
10026       /*TransactionID*/
10027       idx = 0;
10028       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10029       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10030       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10031       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10032
10033       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10034
10035       /* Encode the F1SetupRequest type as UPER */
10036       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10037       encBufSize = 0;
10038       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10039
10040       /* Check encode results */
10041       if(encRetVal.encoded == ENCODE_FAIL)
10042       {
10043          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10044                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10045          break;
10046       }
10047       else
10048       {
10049          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
10050          for(int i=0; i< encBufSize; i++)
10051          {
10052             DU_LOG("%x",encBuf[i]);
10053          }
10054       }
10055
10056       /* Sending msg */
10057       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10058       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
10059       {
10060          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
10061          break;
10062       }
10063
10064       ret = ROK;
10065       break;
10066    }while(true);
10067
10068    FreeF1ResetAck(f1apMsg);
10069    return ret;
10070 }
10071
10072 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10073 {
10074    uint8_t arrIdx =0;
10075
10076    if(ulInfo->list.array)
10077    {
10078       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
10079       {
10080          if(ulInfo->list.array[arrIdx])
10081          {
10082             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
10083             {
10084                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
10085                {
10086                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
10087                   {
10088                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10089                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10090                      gTPTunnel->gTP_TEID.size);
10091                   }
10092                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10093                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10094                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10095                }
10096                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10097                sizeof(GTPTunnel_t));
10098             }
10099             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10100          }
10101       }
10102       CU_FREE(ulInfo->list.array,ulInfo->list.size);
10103    }
10104 }
10105
10106 /*******************************************************************
10107 *
10108 * @brief Deletes the EGTP tunnel
10109 *
10110 * @details
10111 *
10112 *    Function : deleteEgtpTunnel
10113 *
10114 *    Functionality: Deletes the EGTP tunnel
10115 *
10116 * @params[in] uint8_t *buf
10117 *
10118 * @return ROK     - success
10119 *         RFAILED - failure
10120 *
10121 * ****************************************************************/
10122 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
10123 {
10124    uint32_t teId = 0;
10125    EgtpTnlEvt tnlEvt;
10126
10127    teIdStringToInt(buf, &teId);
10128    if(teId > MAX_TEID || teId < MIN_TEID)
10129    {
10130       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
10131       return RFAILED;
10132    }
10133    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
10134    tnlEvt.action = EGTP_TNL_MGMT_DEL;
10135    tnlEvt.lclTeid = teId;
10136    tnlEvt.remTeid = teId;
10137    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
10138    {
10139       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
10140    }
10141    return ROK;
10142 }
10143
10144 /*******************************************************************
10145 *
10146 * @brief Builds the Uplink Tunnel Info
10147 *
10148 * @details
10149 *
10150 *    Function : BuildUlTnlInfoforSetupMod
10151 *
10152 *    Functionality: Constructs the UL TnlInfo For DRB list
10153 *
10154 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10155 *
10156 * @return ROK     - success
10157 *         RFAILED - failure
10158 *
10159 * ****************************************************************/
10160 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
10161 {
10162    uint8_t arrIdx;
10163    uint8_t ulCnt;
10164
10165    ulCnt = 1;
10166    ulInfo->list.count = ulCnt;
10167    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
10168    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
10169    if(ulInfo->list.array == NULLP)
10170    {
10171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10172       return RFAILED;
10173    }
10174    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
10175    {
10176       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10177       if(ulInfo->list.array[arrIdx] == NULLP)
10178       {
10179          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10180          return RFAILED;
10181       }
10182    }
10183
10184    arrIdx = 0;
10185    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
10186    UPTransportLayerInformation_PR_gTPTunnel;
10187
10188    /*GTP TUNNEL*/
10189    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10190          sizeof(GTPTunnel_t));
10191    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
10192    {
10193       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10194       return RFAILED;
10195    }
10196    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10197       transportLayerAddress.size        = 4*sizeof(uint8_t);
10198    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10199          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10200          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10201    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10202          transportLayerAddress.buf == NULLP)
10203    {
10204       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10205       return RFAILED;
10206    }
10207
10208    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10209       transportLayerAddress.buf[0] = 192;
10210    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10211       transportLayerAddress.buf[1] = 168;
10212    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10213       transportLayerAddress.buf[2] = 130;
10214    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10215       transportLayerAddress.buf[3] = 82;
10216    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10217       transportLayerAddress.bits_unused = 0;
10218
10219    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
10220    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
10221    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
10222    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
10223
10224    /*GTP TEID*/
10225    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
10226       = 4 * sizeof(uint8_t);
10227    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10228          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10229          gTPTunnel->gTP_TEID.size);
10230    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10231          == NULLP)
10232    {
10233       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10234       return RFAILED;
10235    }
10236    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10237       gTP_TEID.buf[0] = 0;
10238    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10239       gTP_TEID.buf[1] = 0;
10240    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10241       gTP_TEID.buf[2] = 0;
10242    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
10243    {
10244      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
10245       * fetched based on the Drb Id */
10246
10247      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
10248       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
10249                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
10250    }
10251    else
10252    {
10253       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10254         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
10255    }
10256
10257    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
10258    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
10259    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
10260    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
10261    return ROK;
10262 }/*End of BuildULTnlInfo*/
10263
10264 /*******************************************************************
10265 *
10266 * @brief freeing the DRB item
10267 *
10268 * @details
10269 *
10270 *    Function : FreeDrbItem
10271 *
10272 *    Functionality: freeing the DRB item
10273 *
10274 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10275 *
10276 * @return ROK     - success
10277 *         RFAILED - failure
10278 *
10279 * ****************************************************************/
10280
10281 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
10282 {
10283    uint8_t arrIdx =0;
10284    SNSSAI_t *snssai =NULLP;
10285    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10286
10287    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10288    switch(drbItem->qoSInformation.present)
10289    {
10290       case QoSInformation_PR_NOTHING:
10291          break;
10292       case QoSInformation_PR_eUTRANQoS:
10293          {
10294             if(drbItem->qoSInformation.choice.eUTRANQoS)
10295             {
10296                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10297             }
10298             break;
10299          }
10300       case QoSInformation_PR_choice_extension:
10301          {
10302             if(drbItem->qoSInformation.choice.choice_extension)
10303             {
10304                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10305
10306                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10307                if(snssai->sST.buf)
10308                {
10309                   CU_FREE(snssai->sST.buf,snssai->sST.size);
10310                }
10311                if(snssai->sD)
10312                {
10313                   if(snssai->sD->buf)
10314                   {
10315                      CU_FREE(snssai->sD->buf,snssai->sD->size);
10316                   }
10317                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10318                }
10319
10320                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10321                if(flowMap->list.array)
10322                {
10323                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10324                   {
10325                      if(flowMap->list.array[arrIdx] )
10326                      {
10327                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10328                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10329                      }
10330                   }
10331                   CU_FREE(flowMap->list.array,flowMap->list.size);
10332                }
10333
10334                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10335             }
10336             break;
10337          }
10338
10339    }
10340    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10341    if(drbItem->uLConfiguration)
10342    {
10343       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10344    }
10345 }
10346
10347 /*******************************************************************
10348 *
10349 * @brief filling the DRB setup Mod item
10350 *
10351 * @details
10352 *
10353 *    Function : FillDrbItemToSetupMod
10354 *
10355 *    Functionality: filling the DRB setup Mod item
10356 *
10357 *
10358 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10359 *
10360 * @return ROK     - success
10361 *         RFAILED - failure
10362 *
10363 * ****************************************************************/
10364
10365 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
10366 {
10367    uint8_t ret = ROK;
10368
10369    /*Drb Id */
10370    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
10371    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
10372
10373    /*qoSInformation*/
10374    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10375
10376    switch(drbItem->qoSInformation.present)
10377    {
10378       case QoSInformation_PR_NOTHING:
10379       {
10380          break;
10381       }
10382       case QoSInformation_PR_eUTRANQoS:
10383       {
10384
10385          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10386          if(drbItem->qoSInformation.choice.eUTRANQoS)
10387          {
10388             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10389             return RFAILED;
10390          }
10391          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10392          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10393             PriorityLevel_no_priority;
10394
10395          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10396             Pre_emptionCapability_may_trigger_pre_emption;
10397
10398          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10399             Pre_emptionVulnerability_pre_emptable;
10400
10401          break;
10402       }
10403       case QoSInformation_PR_choice_extension:
10404       {
10405          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10406          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10407          {
10408             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10409             return RFAILED;
10410          }
10411
10412          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10413          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10414          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10415          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10416            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10417          if(ret != ROK)
10418          {
10419             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10420             return RFAILED;
10421          }
10422
10423          /*SNSSAI*/
10424          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10425                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10426          if(ret != ROK)
10427          {
10428             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10429             return RFAILED;
10430          }
10431
10432          /*Flows mapped to DRB List*/
10433          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10434                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10435           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10436          if(ret != ROK)
10437          {
10438             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10439             return RFAILED;
10440          }
10441       }
10442    }
10443
10444    /*ULUPTNLInformation To Be Setup List*/
10445    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10446       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10447    if(ret != ROK)
10448    {
10449       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10450       return RFAILED;
10451    }
10452
10453    /*RLCMode*/
10454    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10455    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10456
10457    ueCb->numDrb++;
10458    return ROK;
10459 }
10460
10461 /*******************************************************************
10462 *
10463 * @brief Builds the DRB to be Setup Mod ItemIes
10464 *
10465 * @details
10466 *
10467 *    Function : FillDrbItemList
10468 *
10469 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10470 *
10471 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10472 *
10473 * @return ROK     - success
10474 *         RFAILED - failure
10475 *
10476 * ****************************************************************/
10477
10478 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10479 {
10480    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10481    drbItemIe->criticality = Criticality_reject;
10482    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10483
10484    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10485    {
10486       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10487       return RFAILED;
10488    }
10489    return ROK;
10490 }
10491 /*******************************************************************
10492 *
10493 * @brief free the DRB to be Setup Mod list
10494 *
10495 * @details
10496 *
10497 *    Function : FreeDrbToBeSetupModList
10498 *
10499 *    Functionality: free the DRB to be Setup Mod list
10500 *
10501 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10502 *
10503 * @return ROK     - success
10504 *         RFAILED - failure
10505 *
10506 * ****************************************************************/
10507 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10508 {
10509    uint8_t arrIdx =0;
10510    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10511
10512    if(drbSet->list.array)
10513    {
10514       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10515       {
10516          if(drbSet->list.array[arrIdx] != NULLP)
10517          {
10518             if(arrIdx == 0)
10519             {
10520                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10521                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10522             }
10523             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10524          }
10525       }
10526       CU_FREE(drbSet->list.array, drbSet->list.size);
10527    }
10528
10529 }
10530
10531 /*******************************************************************
10532 *
10533 * @brief Builds the DRB to be Setup Mod list
10534 *
10535 * @details
10536 *
10537 *    Function : BuildDrbToBeSetupList
10538 *
10539 *    Functionality: Constructs the DRB to be Setup Mod list
10540 *
10541 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10542 *
10543 * @return ROK     - success
10544 *         RFAILED - failure
10545 *
10546 * ****************************************************************/
10547
10548 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10549 {
10550    uint8_t ret = ROK;
10551    uint8_t arrIdx =0;
10552    uint8_t drbCnt =0;
10553
10554    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10555    drbSet->list.count = drbCnt;
10556    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10557    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10558    if(drbSet->list.array == NULLP)
10559    {
10560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10561       return  RFAILED;
10562    }
10563
10564    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10565    {
10566       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10567       if(drbSet->list.array[arrIdx] == NULLP)
10568       {
10569          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10570          return  RFAILED;
10571       }
10572
10573       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10574       if(ret != ROK)
10575       {
10576          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10577       }
10578    }
10579
10580    return ret;
10581 }
10582
10583 /*******************************************************************
10584 *
10585 * @brief Filling the DRB to be modified item
10586 *
10587 * @details
10588 *
10589 *    Function : FillDrbToBeModItem
10590 *
10591 *    Functionality: filling the DRB to be modified item
10592 *
10593 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10594 *
10595 * @return ROK     - success
10596 *         RFAILED - failure
10597 *
10598 * ****************************************************************/
10599
10600 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10601 {
10602    uint8_t ret = ROK;
10603    uint drbIdx=0;
10604    DrbInfo *drbToBeMod;
10605
10606    /*Drb Id */
10607    drbItem->dRBID = DRB2 + arrIdx;
10608
10609    /* Search for DRB ID in CU databse */
10610    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10611    {
10612       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10613       {
10614          drbToBeMod = &ueCb->drbList[drbIdx];
10615          break;
10616       }
10617    }
10618
10619    /*qoSInformation*/
10620    drbItem->qoSInformation = NULLP;
10621    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10622    if(drbItem->qoSInformation != NULLP)
10623    {
10624       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10625
10626       switch(drbItem->qoSInformation->present)
10627       {
10628          case QoSInformation_PR_NOTHING:
10629             {
10630                break;
10631             }
10632          case QoSInformation_PR_eUTRANQoS:
10633             {
10634
10635                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10636                if(drbItem->qoSInformation->choice.eUTRANQoS)
10637                {
10638                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10639                   return RFAILED;
10640                }
10641                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10642                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10643                   PriorityLevel_no_priority;
10644
10645                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10646                   Pre_emptionCapability_may_trigger_pre_emption;
10647
10648                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10649                   Pre_emptionVulnerability_pre_emptable;
10650
10651                break;
10652             }
10653          case QoSInformation_PR_choice_extension:
10654             {
10655                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10656                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10657                {
10658                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10659                   return RFAILED;
10660                }
10661
10662                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10663                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10664                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10665                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10666                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10667                if(ret != ROK)
10668                {
10669                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10670                   return RFAILED;
10671                }
10672
10673                /*SNSSAI*/
10674                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10675                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10676                if(ret != ROK)
10677                {
10678                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10679                   return RFAILED;
10680                }
10681
10682                /*Flows mapped to DRB List*/
10683                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10684                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10685                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10686                if(ret != ROK)
10687                {
10688                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10689                   return RFAILED;
10690                }
10691             }
10692       }
10693    }/* End of QoS */
10694
10695    /*ULUPTNLInformation To Be Setup List*/
10696    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10697             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10698    if(ret != ROK)
10699    {
10700       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10701       return RFAILED;
10702    }
10703    return ROK;
10704 }
10705
10706 /*******************************************************************
10707 *
10708 * @brief Builds the DRB to be modified Item IE
10709 *
10710 * @details
10711 *
10712 *    Function : FillDrbToBeModItemList
10713 *
10714 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10715 *
10716 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10717 *
10718 * @return ROK     - success
10719 *         RFAILED - failure
10720 *
10721 * ****************************************************************/
10722
10723 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10724 {
10725    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10726    drbItemIe->criticality = Criticality_reject;
10727    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10728    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10729    {
10730       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10731       return RFAILED;
10732    }
10733
10734    return ROK;
10735 }
10736
10737 /*******************************************************************
10738 *
10739 * @brief Builds the DRB to be modified list
10740 *
10741 * @details
10742 *
10743 *    Function : BuildDrbToBeModList
10744 *
10745 *    Functionality: Constructs the DRB to be modified list
10746 *
10747 * @params[in] DRBs_ToBeModified_List_t *drbSet
10748 *
10749 * @return ROK     - success
10750 *         RFAILED - failure
10751 *
10752 * ****************************************************************/
10753
10754 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10755 {
10756    uint8_t ret = ROK;
10757    uint8_t arrIdx =0;
10758    uint8_t drbCnt =0;
10759
10760    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10761    drbSet->list.count = drbCnt;
10762    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10763    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10764    if(drbSet->list.array == NULLP)
10765    {
10766       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10767       return  RFAILED;
10768    }
10769    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10770    {
10771       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10772       if(drbSet->list.array[arrIdx] == NULLP)
10773       {
10774          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10775          return  RFAILED;
10776       }
10777
10778       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10779       if(ret != ROK)
10780       {
10781          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10782       }
10783    }
10784
10785    return ret;
10786 }
10787
10788 /*******************************************************************
10789 *
10790 * @brief Builds the DRB to be released Item IE
10791 *
10792 * @details
10793 *
10794 *    Function : FillDrbToBeRelItemList
10795 *
10796 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10797 *
10798 * @params[in] struct DRBs_ToBeReleased_ItemIEs *drbItemIe
10799 *
10800 * @return ROK     - success
10801 *         RFAILED - failure
10802 *
10803 * ****************************************************************/
10804
10805 uint8_t FillDrbToBeRelItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeReleased_ItemIEs *drbItemIe)
10806 {
10807    uint8_t drbIdx;
10808
10809    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeReleased_Item;
10810    drbItemIe->criticality = Criticality_reject;
10811    drbItemIe->value.present = DRBs_ToBeReleased_ItemIEs__value_PR_DRBs_ToBeReleased_Item;
10812    drbItemIe->value.choice.DRBs_ToBeReleased_Item.dRBID = DRB1 + arrIdx;
10813
10814    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10815    {
10816       if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_ToBeReleased_Item.dRBID)
10817       {
10818          deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
10819          CU_FREE(ueCb->drbList[drbIdx].snssai, sizeof(Snssai));
10820          break;
10821       }
10822    }
10823    return ROK;
10824 }
10825
10826 /*******************************************************************
10827 *
10828 * @brief Builds the DRB to be released list
10829 *
10830 * @details
10831 *
10832 *    Function : BuildDrbToBeReleasedList
10833 *
10834 *    Functionality: Constructs the DRB to be released list
10835 *
10836 * @params[in] DRBs_ToBeReleased_List_t *drbSet
10837 *
10838 * @return ROK     - success
10839 *         RFAILED - failure
10840 *
10841 * ****************************************************************/
10842
10843 uint8_t BuildDrbToBeReleasedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeReleased_List_t *drbSet)
10844 {
10845    uint8_t ret = ROK;
10846    uint8_t arrIdx =0;
10847    uint8_t drbCnt =0;
10848
10849    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10850    drbSet->list.count = drbCnt;
10851    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeReleased_ItemIEs_t *);
10852    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10853    if(drbSet->list.array == NULLP)
10854    {
10855       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
10856       return  RFAILED;
10857    }
10858    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10859    {
10860       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeReleased_ItemIEs_t));
10861       if(drbSet->list.array[arrIdx] == NULLP)
10862       {
10863          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeReleasedList");
10864          return  RFAILED;
10865       }
10866
10867       ret = FillDrbToBeRelItemList(duId, ueCb, arrIdx, (DRBs_ToBeReleased_ItemIEs_t *)drbSet->list.array[arrIdx]);
10868       if(ret != ROK)
10869       {
10870          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeRelItemList failed");
10871       }
10872    }
10873
10874    return ret;
10875 }
10876
10877 /*******************************************************************
10878 *
10879 * @brief freeing the DRB  item
10880 *
10881 * @details
10882 *
10883 *    Function : FreeModifiedDrbItem
10884 *
10885 *    Functionality: freeing the DRB 2 item
10886 *
10887 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10888 *
10889 * @return ROK     - success
10890 *         RFAILED - failure
10891 *
10892 * ****************************************************************/
10893
10894 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10895 {
10896    uint8_t arrIdx =0;
10897    SNSSAI_t *snssai =NULLP;
10898    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10899
10900    if(drbItem->qoSInformation != NULLP)
10901    {
10902       switch(drbItem->qoSInformation->present)
10903       {
10904          case QoSInformation_PR_NOTHING:
10905             break;
10906          case QoSInformation_PR_eUTRANQoS:
10907             {
10908                if(drbItem->qoSInformation->choice.eUTRANQoS)
10909                {
10910                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10911                }
10912                break;
10913             }
10914          case QoSInformation_PR_choice_extension:
10915             {
10916                if(drbItem->qoSInformation->choice.choice_extension)
10917                {
10918                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10919
10920                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10921                   if(snssai->sST.buf)
10922                   {
10923                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10924                   }
10925                   if(snssai->sD)
10926                   {
10927                      if(snssai->sD->buf)
10928                      {
10929                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10930                      }
10931                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10932                   }
10933
10934                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10935                   if(flowMap->list.array)
10936                   {
10937                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10938                      {
10939                         if(flowMap->list.array[arrIdx] )
10940                         {
10941                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10942                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10943                         }
10944                      }
10945                      CU_FREE(flowMap->list.array,flowMap->list.size);
10946                   }
10947
10948                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10949                }
10950                break;
10951             }
10952       }
10953    }
10954    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10955    if(drbItem->uLConfiguration)
10956    {
10957       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10958    }
10959 }
10960
10961 /*******************************************************************
10962 *
10963 * @brief free the DRB to be modfified list
10964 *
10965 * @details
10966 *
10967 *    Function : FreeDrbToBeModifiedList
10968 *
10969 *    Functionality: free the DRB to be Setup Mod list
10970 *
10971 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10972 *
10973 * @return ROK     - success
10974 *         RFAILED - failure
10975 *
10976 * ****************************************************************/
10977 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10978 {
10979    uint8_t arrIdx =0;
10980    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10981
10982    if(drbSet->list.array)
10983    {
10984       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10985       {
10986          if(drbSet->list.array[arrIdx] != NULLP)
10987          {
10988             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10989             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10990             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10991          }
10992       }
10993       CU_FREE(drbSet->list.array, drbSet->list.size);
10994    }
10995
10996 }
10997
10998 /*******************************************************************
10999 *
11000 * @brief free the DRB to be modfified list
11001 *
11002 * @details
11003 *
11004 *    Function : FreeDrbToBeReleasedList
11005 *
11006 *    Functionality: free the DRB to be Release list
11007 *
11008 * @params[in] FreeDrbToBeReleasedList_t *drbSet
11009 *
11010 * @return ROK     - success
11011 *         RFAILED - failure
11012 *
11013 * ****************************************************************/
11014 void FreeDrbToBeReleasedList(DRBs_ToBeReleased_List_t *drbSet)
11015 {
11016    uint8_t arrIdx =0;
11017    struct DRBs_ToBeReleased_ItemIEs *drbItemIe;
11018
11019    if(drbSet->list.array)
11020    {
11021       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
11022       {
11023          if(drbSet->list.array[arrIdx] != NULLP)
11024          {
11025             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeReleased_ItemIEs_t));
11026          }
11027       }
11028       CU_FREE(drbSet->list.array, drbSet->list.size);
11029    }
11030 }
11031
11032 /*******************************************************************
11033  *
11034  * @brief  free the UeContextModification Request
11035  *
11036  * @details
11037  *
11038  *    Function : FreeUeContextModicationRequest
11039  *
11040  *    Functionality : deallocation of memory allocated in UeContextModiification
11041  request
11042  *
11043  * @params[in] F1AP_PDU_t *f1apMsg
11044  *
11045  * @return void
11046 *
11047 * ****************************************************************/
11048 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
11049 {
11050    uint8_t arrIdx =0 , ieId=0;
11051    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
11052
11053    if(f1apMsg)
11054    {
11055       if(f1apMsg->choice.initiatingMessage)
11056       {
11057          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
11058          if(ueContextModifyReq->protocolIEs.list.array)
11059          {
11060             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
11061             {
11062                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
11063                {
11064                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
11065                   switch(ieId)
11066                   {
11067                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11068                         break;
11069                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11070                         break;
11071                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
11072                         {
11073                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11074                                  choice.DRBs_ToBeSetupMod_List);
11075                            break;
11076                         }
11077                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
11078                         {
11079                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11080                                  choice.DRBs_ToBeModified_List);
11081                            break;
11082                         }
11083                      case ProtocolIE_ID_id_DRBs_ToBeReleased_List:
11084                         {
11085                            FreeDrbToBeReleasedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
11086                                  choice.DRBs_ToBeReleased_List);
11087                            break;
11088                         }
11089                     case ProtocolIE_ID_id_TransmissionActionIndicator:
11090                         break;
11091                     case ProtocolIE_ID_id_RRCContainer:
11092                     {
11093                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
11094                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
11095                     }
11096
11097                   }
11098                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
11099                }
11100             }
11101             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
11102          }
11103          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11104       }
11105       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11106    }
11107 }
11108
11109 /*******************************************************************
11110  *
11111  * @brief Builds the Ue Context Modification Req
11112  *
11113  * @details
11114  *
11115  *    Function : BuildAndSendUeContextModificationReq
11116  *
11117  *    Functionality: Constructs the Ue Context Modification Req
11118  *
11119  * @params[in]
11120  *
11121  * @return ROK     - success
11122  *         RFAILED - failure
11123  *
11124  * ****************************************************************/
11125 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
11126 {
11127    uint8_t    ieIdx = 0;
11128    uint8_t    elementCnt = 0;
11129    uint8_t    ret = RFAILED;
11130    uint16_t   tmpBufIdx = 0, bufIdx = 0;
11131    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
11132    F1AP_PDU_t *f1apMsg = NULLP;
11133    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
11134    RRCContainer_t rrcContainerTmp, *rrcContainer = NULLP;
11135    asn_enc_rval_t         encRetVal;
11136    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
11137    while(1)
11138    {
11139       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11140       if(f1apMsg == NULLP)
11141       {
11142          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11143          break;
11144       }
11145
11146       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11147
11148       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11149       if(f1apMsg->choice.initiatingMessage == NULLP)
11150       {
11151          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11152          break;
11153       }
11154       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
11155       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11156       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
11157
11158       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
11159
11160       if(action == MODIFY_UE)
11161          elementCnt = 5;
11162       else if(action == QUERY_CONFIG)
11163          elementCnt = 3;
11164       else if(action == RRC_RECONFIG_COMPLETE_IND)
11165          elementCnt = 3;
11166       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11167          elementCnt = 5;
11168
11169 #ifdef NR_DRX
11170       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
11171          elementCnt++;
11172 #endif
11173       ueContextModifyReq->protocolIEs.list.count = elementCnt;
11174       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
11175
11176       /* Initialize the UE context modification members */
11177       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
11178       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
11179       {
11180          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11181          break;
11182       }
11183
11184       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11185       {
11186          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
11187          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
11188          {
11189             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11190             break;
11191          }
11192       }
11193
11194       ieIdx=0;
11195       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11196       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11197       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11198                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
11199       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
11200
11201       ieIdx++;
11202       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11203       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11204       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
11205                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
11206       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
11207
11208       if(action == MODIFY_UE)
11209       {
11210          /* DRB to be setup list */
11211          ieIdx++;
11212          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
11213          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11214          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11215                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
11216          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11217                   value.choice.DRBs_ToBeSetupMod_List));
11218
11219          /* DRB to be modified list */
11220          ieIdx++;
11221          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
11222          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11223          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11224                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
11225          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11226                   value.choice.DRBs_ToBeModified_List));
11227
11228          if(ret != ROK)
11229          {
11230             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
11231             break;
11232          }
11233
11234          /* DRB to be released list */
11235          ieIdx++;
11236          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeReleased_List;
11237          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11238          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11239                                                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeReleased_List;
11240          ret = BuildDrbToBeReleasedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11241                   value.choice.DRBs_ToBeReleased_List));
11242
11243          if(ret != ROK)
11244          {
11245             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be deleted list");
11246             break;
11247          }
11248       }
11249       else if(action == QUERY_CONFIG)
11250       {
11251          ieIdx++;
11252          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
11253          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11254          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11255             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
11256          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
11257       }
11258       else if(action == RRC_RECONFIG_COMPLETE_IND)
11259       {
11260          ieIdx++;
11261          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
11262          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11263          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11264             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
11265          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
11266             RRCReconfigurationCompleteIndicator_true;
11267       }
11268       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11269       {
11270          ieIdx++;
11271          if(action == STOP_DATA_TX)
11272          {
11273             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11274             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11275             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11276             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11277             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11278             TransmissionActionIndicator_stop;
11279          }
11280          else if (action == RESTART_DATA_TX)
11281          {
11282             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11283             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11284             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11285             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11286             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11287             TransmissionActionIndicator_restart;
11288          }
11289
11290          ieIdx++;
11291          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11292          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11293          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCContainer;
11294          if(fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, true) != ROK)
11295          {
11296             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
11297             return RFAILED;
11298          }
11299
11300          rrcContainer = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11301          rrcContainer->size = rrcContainerTmp.size + 2; /* 2 bytes of PDCP SN */
11302          CU_ALLOC(rrcContainer->buf, rrcContainer->size);
11303          memset(rrcContainer->buf, 0, rrcContainer->size);
11304          rrcContainer->buf[0] = 0x00;
11305          rrcContainer->buf[1] = ueCb->pdcpSn; //PDCP SN
11306          for(bufIdx = 2, tmpBufIdx = 0; bufIdx < rrcContainer->size; bufIdx++, tmpBufIdx++)
11307          {
11308             rrcContainer->buf[bufIdx] = rrcContainerTmp.buf[tmpBufIdx];
11309          }
11310
11311          /* RRC delivery status request */
11312          ieIdx++;
11313          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
11314          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11315          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
11316          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
11317       }
11318
11319 #ifdef NR_DRX
11320       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
11321       {
11322          /* DRX Configuration Indicator */
11323          ieIdx++;
11324          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRXConfigurationIndicator;
11325          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11326          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_DRXConfigurationIndicator;
11327          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.DRXConfigurationIndicator = DRXConfigurationIndicator_release;
11328          ueCb->drxCfgPresent = false;
11329          memset(&ueCb->drxCfg, 0, sizeof(DrxCfg));
11330       }
11331 #endif
11332
11333       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11334
11335       /* Encode the F1SetupRequest type as APER */
11336       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11337       encBufSize = 0;
11338       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11339
11340       /* Encode results */
11341       if(encRetVal.encoded == ENCODE_FAIL)
11342       {
11343          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
11344                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11345          break;
11346       }
11347       else
11348       {
11349          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
11350 #if 0
11351          /* This for loop was going into an infinite loop even though encBufSize
11352           * has a small value. Hence commented this
11353           */
11354          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11355          {
11356             DU_LOG("%x",encBuf[ieIdx]);
11357          }
11358 #endif
11359       }
11360
11361       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11362       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11363       {
11364          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
11365          break;
11366       }
11367
11368       ret = ROK;
11369       break;
11370
11371    }
11372    FreeUeContextModicationRequest(f1apMsg);
11373    return ret;
11374 }
11375
11376 /*****************************************************************i
11377  *
11378 * @brief Free memory allocated for UE Context Release Command
11379 *
11380 * @details
11381 *
11382 *    Function : FreeUeContextReleaseCommand
11383 *
11384 *    Functionality:
11385 *         - Free memory allocated for UE Context Release Command
11386 *
11387 * @params[in] F1AP_PDU_t *f1apMsg
11388 * @return void
11389 *
11390 * *************************************************************/
11391 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
11392 {
11393    uint8_t ieIdx;
11394    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
11395
11396    if(f1apMsg)
11397    {
11398       if(f1apMsg->choice.initiatingMessage)
11399       {
11400          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11401          if(ueReleaseCommand->protocolIEs.list.array)
11402          {
11403             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
11404             {
11405                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11406             }
11407             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
11408          }
11409          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11410       }
11411       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11412    }
11413 }
11414 /*******************************************************************
11415  *
11416  * @brief Builds the Ue Context Release Command
11417  *
11418  * @details
11419 *
11420 *    Function : BuildAndSendUeContextReleaseCommand
11421 *
11422 *    Functionality: Constructs the Ue Context Release Command
11423 *
11424 * @params[in]
11425 *
11426 * @return ROK     - success
11427 *         RFAILED - failure
11428 *
11429 * ****************************************************************/
11430 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
11431 {
11432    bool       memAllocFailed = false;
11433    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
11434    DuDb *duDb;
11435    CuUeCb *ueCb;
11436    F1AP_PDU_t *f1apMsg = NULLP;
11437    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
11438
11439    asn_enc_rval_t         encRetVal;
11440    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
11441
11442    while(true)
11443    {
11444       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11445       if(f1apMsg == NULLP)
11446       {
11447          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
11448          break;
11449       }
11450
11451       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11452
11453       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11454       if(f1apMsg->choice.initiatingMessage == NULLP)
11455       {
11456          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
11457          break;
11458       }
11459       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
11460       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11461       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
11462
11463       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11464
11465       SEARCH_DU_DB(duIdx, duId, duDb);
11466       ueCb = &duDb->ueCb[duUeF1apId-1];
11467       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11468          elementCnt = 3;
11469       else
11470          elementCnt = 4;
11471
11472       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
11473       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
11474
11475       /* Initialize the UE context modification members */
11476       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
11477       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
11478       {
11479          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
11480          break;
11481       }
11482
11483       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11484       {
11485          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11486          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
11487          {
11488             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
11489             memAllocFailed = true;
11490             break;
11491          }
11492       }
11493
11494       if(memAllocFailed == true)
11495       {
11496          break;
11497       }
11498
11499       ieIdx=0;
11500       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11501       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11502       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11503       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
11504       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
11505
11506       ieIdx++;
11507       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11508       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11509       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11510       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
11511       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
11512
11513       /* Cause of UE context release */
11514       ieIdx++;
11515       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
11516       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11517       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11518                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
11519       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11520       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
11521                                                                                                      CauseRadioNetwork_normal_release;
11522       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11523       {
11524          /* RRC Container for RRC release */
11525          ieIdx++;
11526          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11527          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11528          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11529                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
11530          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
11531          bufLen =7;
11532          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
11533          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
11534                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
11535          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
11536          {
11537             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
11538             break;
11539          }
11540          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
11541          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
11542       }
11543       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11544
11545       /* Encode the UE Context Release Command type as APER */
11546       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11547       encBufSize = 0;
11548       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11549             encBuf);
11550
11551       /* Encode results */
11552       if(encRetVal.encoded == ENCODE_FAIL)
11553       {
11554          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11555                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11556          break;
11557       }
11558       else
11559       {
11560          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
11561          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11562          {
11563             DU_LOG("%x",encBuf[ieIdx]);
11564          }
11565       }
11566
11567       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11568       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11569       {
11570          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11571          break;
11572       }
11573
11574       ret = ROK;
11575       break;
11576
11577    }
11578    FreeUeContextReleaseCommand(f1apMsg);
11579    return ret;
11580 }
11581 /*******************************************************************
11582 *
11583 * @brief process Ue context release request
11584 *
11585 * @details
11586 *
11587 *    Function : procUeContextReleaseReq
11588 *
11589 *    Functionality:
11590 *         - process Ue context release request
11591 *
11592 * @params[in] F1AP_PDU_t *f1apMsg
11593 * @return ROK     - success
11594 *         RFAILED - failure
11595 *
11596 * ****************************************************************/
11597 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11598 {
11599    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11600
11601    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11602    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11603
11604    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11605    {
11606       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11607       {
11608          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11609             {
11610                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11611                break;
11612             }
11613          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11614             {
11615                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11616                break;
11617             }
11618          default:
11619               break;
11620       }
11621    }
11622
11623    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11624    {
11625       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11626       return RFAILED;
11627    }
11628    return ROK;
11629 }
11630 /*******************************************************************
11631 *
11632 * @brief processing of Gnb-DU config update
11633 *
11634 * @details
11635 *
11636 *    Function : procGnbDuUpdate
11637 *
11638 *    Functionality:
11639 *         - processing of Gnb-DU config update
11640 *
11641 * @params[in] F1AP_PDU_t *f1apMsg
11642 * @return ROK     - success
11643 *         RFAILED - failure
11644 *
11645 * ****************************************************************/
11646 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11647 {
11648    bool cellToBeDelete = false;
11649    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11650    uint16_t nrCellId;
11651    DuDb *duDb;
11652    CuCellCb *cellCb;
11653    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11654
11655    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11656    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11657    {
11658       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11659       {
11660          case ProtocolIE_ID_id_TransactionID:
11661             break;
11662          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11663             break;
11664          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11665             {
11666                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11667                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11668                   Served_Cells_To_Delete_List.list.array[0];
11669                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11670                cellToBeDelete = true;
11671                break;
11672             }
11673          case ProtocolIE_ID_id_gNB_DU_ID:
11674             break;
11675       }
11676    }
11677    if(BuildAndSendDUUpdateAck(duId) != ROK)
11678    {
11679       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11680       return RFAILED;
11681    }
11682 #if 0
11683    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11684     * commented this trigger for now */
11685
11686    if(cellToBeDelete == false)
11687    {
11688       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11689       if(BuildAndSendF1ResetReq() != ROK)
11690       {
11691          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11692          return RFAILED;
11693       }
11694    }
11695 #endif
11696    if(cellToBeDelete == true)
11697    {
11698       SEARCH_DU_DB(duIdx, duId, duDb);
11699       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11700       if(cellCb->numUe == 0)
11701       {
11702          memset(cellCb, 0, sizeof(CuCellCb));
11703          duDb->numCells--;
11704       }
11705       else
11706          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11707    }
11708    return ROK;
11709 }
11710
11711 /*******************************************************************
11712 *
11713 * @brief storing slice list in CU database
11714 *
11715 * @details
11716 *
11717 *    Function : buildSliceList
11718 *
11719 *    Functionality:
11720 *         - storing slice list in CU database
11721 *
11722 * @params[in] SliceSupportList_t *sliceSupportList
11723 * @return ROK     - success
11724 *         RFAILED - failure
11725 *
11726 * ****************************************************************/
11727 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11728 {
11729    uint8_t sliceListIdx = 0;
11730
11731    if(sliceSupportList)
11732    {
11733       if(sliceSupportList->list.array)
11734       {
11735          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11736          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11737          {
11738             if(sliceSupportList->list.array[sliceListIdx])
11739             {
11740                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11741                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11742                {
11743                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11744                    return RFAILED;
11745                }
11746                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11747                {
11748                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11749                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11750                }
11751                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11752                {
11753                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11754                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11755                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11756                }
11757             }
11758          }
11759       }
11760    }
11761    return ROK;
11762 }
11763
11764 /****************************************************************
11765  * @brief Function to process Srb Setup Mod List
11766  *
11767  * @details
11768  *
11769  *    Function : procSrbSetupModList
11770  *
11771  *    Functionality:
11772  *         - Function to process SRB Setup Mod List
11773  *
11774  * @params[in]
11775  * @return ROK     - success
11776  *         RFAILED - failure
11777  *
11778  * ****************************************************************/
11779 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11780 {
11781    uint8_t arrIdx = 0, srbIdx;
11782    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11783
11784    if(srbSetupList != NULLP)
11785    {
11786       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11787       {
11788          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11789          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11790          {
11791             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11792             {
11793                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11794                {
11795                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11796                   break;
11797                }
11798             }
11799          }
11800
11801       }
11802    }
11803    return ROK;
11804 }
11805
11806
11807 /****************************************************************
11808  * @brief Function to process Drb Setup Mod List
11809  *
11810  * @details
11811  *
11812  *    Function : procDrbSetupModList
11813  *
11814  *    Functionality:
11815  *         - Function to process DRB Setup Mod List
11816  *
11817  * @params[in]
11818  * @return ROK     - success
11819  *         RFAILED - failure
11820  *
11821  * ****************************************************************/
11822 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11823 {
11824    uint8_t arrIdx = 0, drbIdx;
11825    uint32_t teId = 0;
11826    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11827
11828    if(drbSetupList != NULLP)
11829    {
11830       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11831       {
11832          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11833          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11834          {
11835             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11836             {
11837                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11838                {
11839                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11840                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11841                   break;
11842                }
11843             }
11844
11845             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11846             {
11847                /* extracting teId */
11848                teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11849                if(teId > 0)
11850                {
11851                   if(addDrbTunnels(duId, teId)== ROK)
11852                   {
11853                      DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11854                   }
11855                }
11856                else
11857                   return RFAILED;
11858             }
11859          }
11860       }
11861    }
11862    return ROK;
11863 }
11864
11865 /*******************************************************************
11866 *
11867 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11868 *
11869 * @details
11870 *
11871 *    Function : procServedCellPlmnList
11872 *
11873 *    Functionality:
11874 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11875 *         SNSSAI list
11876 *
11877 * @params[in] F1AP_PDU_t *f1apMsg
11878 * @return ROK     - success
11879 *         RFAILED - failure
11880 *
11881 * ****************************************************************/
11882 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11883 {
11884    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11885    ProtocolExtensionContainer_4624P3_t **ieExtend;
11886
11887    if(srvPlmn->list.array)
11888    {
11889       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11890       {
11891          if(srvPlmn->list.array[srvPlmnIdx])
11892          {
11893             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11894             if(*ieExtend)
11895             {
11896                if((*ieExtend)->list.array)
11897                {
11898                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11899                   {
11900                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11901                      {
11902                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11903                         {
11904                            case ProtocolIE_ID_id_TAISliceSupportList:
11905                               {
11906                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11907                                           extensionValue.choice.SliceSupportList) != ROK)
11908                                  {
11909                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11910                                     return RFAILED;
11911                                  }
11912                               }
11913                         }
11914                      }
11915                   }
11916                }
11917             }
11918          }
11919       }
11920    }
11921    return ROK;
11922 }
11923
11924 /****************************************************************
11925  * @brief Function to process Ue Context Modification Response
11926  *
11927  * @details
11928  *
11929  *    Function : procUeContextModificationResponse
11930  *
11931  *    Functionality:
11932  *         - Function to process Ue Context Modification Response
11933  *
11934  * @params[in]
11935  * @return ROK     - success
11936  *         RFAILED - failure
11937  *
11938  * ****************************************************************/
11939 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg, char *recvBuf, MsgLen recvBufLen)
11940 {
11941    uint8_t idx=0, duIdx=0;
11942    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11943    DuDb *duDb = NULLP;
11944    CuUeCb *ueCb = NULLP;
11945    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11946
11947    SEARCH_DU_DB(duIdx, duId, duDb);
11948    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11949
11950    /* In case of Inter-CU Handover request received from peer CU */
11951    if(duDb->tempUeCtxtInHo)
11952       ueCb = duDb->tempUeCtxtInHo;
11953
11954    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11955    {
11956       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11957       {
11958           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11959              {
11960                 if(ueCb == NULLP)
11961                 {
11962                    cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11963                 }
11964                 else
11965                 {
11966                    /* In case of Inter-CU Handover request received from peer CU */
11967                    cuUeF1apId = ueCb->gnbCuUeF1apId;
11968                 }
11969                 break;
11970              }
11971           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11972              {
11973                 if(!ueCb)
11974                 {
11975                    duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11976                    ueCb = &duDb->ueCb[duUeF1apId-1];
11977
11978                    /* In case UE context modification response is received at source GNB CU from source GNB DU
11979                     * for a UE in handover, send HO request to target GNB only if not sent already.
11980                     * If HO Req is already sent to target GNB, and an HO Req Ack is received, then
11981                     * ueCb->hoInfo.cuUeF1apIdTgt will be non-zero
11982                     */
11983                    if((ueCb->state == UE_HANDOVER_IN_PROGRESS) && (ueCb->hoInfo.HOType == Xn_Based_Inter_CU_HO) && \
11984                       (ueCb->hoInfo.cuUeF1apIdTgt == 0))
11985                    {
11986                       BuildAndSendHOReq(ueCb, recvBuf, recvBufLen);
11987                    }
11988                 }
11989                 break;
11990              }
11991           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11992              {
11993                 /* Adding Tunnels for successful DRB */
11994                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11995                 break;
11996
11997              }
11998              case ProtocolIE_ID_id_DRBs_Modified_List:
11999              {
12000                 DU_LOG("\nINFO  -->  Received DRBs Modified List");
12001                 break;
12002              }
12003           case ProtocolIE_ID_id_SRBs_SetupMod_List:
12004              {
12005                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
12006                 break;
12007              }
12008          case ProtocolIE_ID_id_DUtoCURRCInformation:
12009              {
12010                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
12011                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
12012                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
12013                 {
12014                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
12015                    return RFAILED;
12016                 }
12017                 break;
12018              }
12019
12020       }
12021    }
12022
12023    /* If UE is in handover and UE context is not yet created at target DU, then send
12024     * UE context setup request to target DU */
12025    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
12026    {
12027       uint8_t ueIdx = 0;
12028       uint8_t tgtDuId = 0;
12029       DuDb *tgtDuDb = NULLP;
12030       CuUeCb *ueCbInTgtDu = NULLP;
12031
12032       if(ueCb->hoInfo.HOType == Inter_DU_HO)
12033       {
12034          tgtDuId = ueCb->hoInfo.tgtNodeId;
12035       }
12036       else if (ueCb->hoInfo.HOType == Xn_Based_Inter_CU_HO)
12037       {
12038          tgtDuId =  duId;
12039       }
12040
12041       SEARCH_DU_DB(duIdx, tgtDuId, tgtDuDb);
12042       if(tgtDuDb)
12043       {
12044          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
12045           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
12046           * DB */
12047          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
12048          {
12049             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
12050             {
12051                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
12052                break;
12053             }
12054          }
12055
12056          /* If UE context is not found in Target DU, send UE context setup
12057           * request */
12058          if(ueCbInTgtDu == NULLP)
12059          {
12060             if((BuildAndSendUeContextSetupReq(tgtDuId, ueCb)) != ROK)
12061             {
12062                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
12063                return RFAILED;
12064             }
12065          }
12066       }
12067    }
12068
12069 #ifdef START_DL_UL_DATA
12070    startDlData();
12071 #endif
12072
12073    return ROK;
12074 }
12075
12076 /*******************************************************************
12077 *
12078 * @brief processing of F1 setup request
12079 *
12080 * @details
12081 *
12082 *    Function : procF1SetupReq
12083 *
12084 *    Functionality:
12085 *         - processing of  F1 setup request
12086 *
12087 * @params[in] F1AP_PDU_t *f1apMsg
12088 * @return ROK     - success
12089 *         RFAILED - failure
12090 *
12091 * ****************************************************************/
12092 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
12093 {
12094    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
12095    uint32_t duId = 0;
12096    uint64_t nrCellId = 0;
12097    DuDb     *duDb = NULLP;
12098    CuCellCb *cellCb = NULLP;
12099    BIT_STRING_t nrcellIdentity;
12100    F1SetupRequest_t *f1SetupReq = NULLP;
12101    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
12102    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
12103
12104    /* Triggering XN setup request before F1 setup establishment */
12105    if(LOCAL_NODE_TYPE == CLIENT)
12106       BuildAndSendXnSetupReq();
12107
12108    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
12109    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
12110    {
12111       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
12112       {
12113          case ProtocolIE_ID_id_gNB_DU_ID:
12114            {
12115               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
12116               SEARCH_DU_DB(duIdx, duId, duDb);
12117               if(duDb == NULLP)
12118               {
12119                  duDb = &cuCb.duInfo[cuCb.numDu];
12120                  cuCb.numDu++;
12121               }
12122               memset(duDb, 0, sizeof(DuDb));
12123               duDb->duId = duId;
12124               *destDuId = duId;
12125               break;
12126            }
12127          case ProtocolIE_ID_id_gNB_DU_Name:
12128            {
12129               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
12130               break;
12131            }
12132          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
12133            {
12134                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
12135                if(duServedCell->list.array)
12136                {
12137                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
12138                   {
12139                      if(duServedCell->list.array[plmnidx])
12140                      {
12141                         switch(duServedCell->list.array[plmnidx]->id)
12142                         {
12143                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
12144                            {
12145                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
12146                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
12147                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
12148
12149                               bitStringToInt(&nrcellIdentity, &nrCellId);
12150                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
12151                               if(cellCb == NULLP)
12152                               {
12153                                  cellCb = &duDb->cellCb[duDb->numCells];
12154                                  memset(cellCb, 0, sizeof(CuCellCb));
12155                                  cellCb->nrCellId = nrCellId;
12156                                  cellCb->cellStatus = CELL_ACTIVE;
12157                                  duDb->numCells++;
12158                               }
12159                            }
12160                         }
12161                      }
12162                   }
12163                }
12164            }
12165       }
12166    }
12167    if(ret == ROK)
12168    {
12169       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
12170    }
12171    else
12172    {
12173        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
12174    }
12175 }
12176
12177 /****************************************************************
12178 *
12179 * @brief processing of UE Context Release Complete
12180 *
12181 * @details
12182 *
12183 *    Function : procUeContextReleaseComplete
12184 *
12185 *    Functionality:
12186 *         - processing of UE Context Release Complete
12187 *
12188 * @params[in] F1AP_PDU_t *f1apMsg
12189 * @return ROK     - success
12190 *         RFAILED - failure
12191 *
12192 * ****************************************************************/
12193 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
12194 {
12195    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
12196    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
12197    DuDb *duDb = NULLP;
12198    CuUeCb *ueCb = NULLP;
12199    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12200
12201    SEARCH_DU_DB(duIdx, duId, duDb);
12202    if(!duDb)
12203    {
12204       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
12205       return;
12206    }
12207
12208    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12209    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
12210    {
12211       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
12212       {
12213          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12214             {
12215                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12216                break;
12217             }
12218          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12219             {
12220                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12221                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
12222                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
12223                {
12224                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
12225                   {
12226                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
12227                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
12228                      {
12229                         for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
12230                         {
12231                            deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
12232                         }
12233                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
12234                         ueCb->cellCb->numUe--;
12235                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
12236                         {
12237                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
12238                            duDb->numCells--;
12239                         }
12240                         break;
12241                      }
12242                   }
12243                }
12244                memset(ueCb, 0, sizeof(CuUeCb));
12245                duDb->numUe--;
12246                break;
12247             }
12248       }
12249    }
12250 }
12251
12252 /*******************************************************************
12253  *
12254  * @brief Builds the Paging cell list
12255  *
12256  * @details
12257  *
12258  *    Function : BuildPagingCellList
12259  *
12260  *    Functionality: Build the paging cell list
12261  *
12262  * @params[in] PagingCell_list_t  *pagingCelllist,
12263  *
12264  * @return ROK     - success
12265  *         RFAILED - failure
12266  *
12267  * ****************************************************************/
12268 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
12269 {
12270    uint8_t cellIdx =0;
12271    PagingCell_ItemIEs_t *pagingCellItemIes;
12272    PagingCell_Item_t *pagingCellItem;
12273
12274    pagingCelllist->list.count = numCells;
12275    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
12276    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
12277    if(pagingCelllist->list.array == NULLP)
12278    {
12279       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12280       return RFAILED;
12281    }
12282
12283    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12284    {
12285       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12286       if(pagingCelllist->list.array[cellIdx] == NULLP)
12287       {
12288          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12289          return RFAILED;
12290       }
12291    }
12292
12293    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12294    {
12295       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12296       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
12297       pagingCellItemIes->criticality = Criticality_ignore;
12298       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
12299       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12300
12301       /* Fill NrCgi Information */
12302       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
12303    }
12304
12305    return ROK;
12306 }
12307
12308 /*******************************************************************
12309  *
12310  * @brief Deallocation of memory allocated in paging msg
12311  *
12312  * @details
12313  *
12314  *    Function :FreePagingMsg
12315  *
12316  *    Functionality: Deallocation of memory allocated in paging msg
12317  *
12318  * @params[in] F1AP_PDU_t *f1apMsg
12319  *
12320  * @return void
12321  *
12322  * ****************************************************************/
12323 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
12324 {
12325    uint8_t ieIdx, cellIdx;
12326    Paging_t   *paging;
12327    PagingCell_ItemIEs_t *pagingCellItemIes;
12328    PagingCell_Item_t *pagingCellItem;
12329    PagingCell_list_t  *pagingCelllist;
12330
12331    if(f1apMsg)
12332    {
12333       if(f1apMsg->choice.initiatingMessage)
12334       {
12335          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12336          if(paging->protocolIEs.list.array)
12337          {
12338             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
12339             {
12340                if(paging->protocolIEs.list.array[ieIdx])
12341                {
12342                   switch(paging->protocolIEs.list.array[ieIdx]->id)
12343                   {
12344                      case ProtocolIE_ID_id_UEIdentityIndexValue:
12345                      {
12346                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12347                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12348                         break;
12349                      }
12350
12351                      case ProtocolIE_ID_id_PagingIdentity:
12352                      {
12353                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
12354                         {
12355                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12356                            {
12357                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
12358                               {
12359                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12360                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12361                               }
12362                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
12363                                 sizeof(struct CNUEPagingIdentity));
12364                            }
12365                         }
12366                         break;
12367                      }
12368
12369                      case ProtocolIE_ID_id_PagingCell_List:
12370                      {
12371                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
12372                         if(pagingCelllist->list.array)
12373                         {
12374                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12375                            {
12376                               if(pagingCelllist->list.array[cellIdx])
12377                               {
12378                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12379                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
12380                                   {
12381                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12382                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
12383                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
12384                                   }
12385                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12386                               }
12387                            }
12388                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
12389                         }
12390                         break;
12391                      }
12392                   }
12393                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12394                }
12395             }
12396             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12397          }
12398          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12399       }
12400       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12401    }
12402 }
12403 /*******************************************************************
12404  *
12405  * @brief Builds and sends the paging message if UE is in idle mode
12406  *
12407  * @details
12408  *
12409  *    Function : BuildAndSendPagingMsg
12410  *
12411  *    Functionality: Builds and sends the paging message
12412  *
12413  * @params[in] uint32_t duId, uint8_t gsTmsi
12414  *
12415  * @return ROK     - success
12416  *         RFAILED - failure
12417  *
12418  * ****************************************************************/
12419 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
12420 {
12421    bool       memAllocFailed = false;
12422    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
12423    uint16_t   ueId = 0, duIdx = 0;
12424
12425    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
12426     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
12427    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
12428    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
12429
12430    F1AP_PDU_t *f1apMsg = NULLP;
12431    Paging_t   *paging = NULLP;
12432    DuDb       *duDb;
12433    asn_enc_rval_t         encRetVal;
12434
12435    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
12436
12437    SEARCH_DU_DB(duIdx, duId, duDb);
12438    if(duDb == NULLP)
12439    {
12440       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
12441       return ret;
12442    }
12443    if(duDb->numCells == 0)
12444    {
12445       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): No CELL is UP!");
12446       return ret;
12447    }
12448
12449    while(true)
12450    {
12451       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12452       if(f1apMsg == NULLP)
12453       {
12454          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
12455          break;
12456       }
12457
12458       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
12459
12460       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12461       if(f1apMsg->choice.initiatingMessage == NULLP)
12462       {
12463          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
12464          break;
12465       }
12466       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
12467       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12468       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
12469
12470       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12471
12472       elementCnt = 5;
12473       paging->protocolIEs.list.count = elementCnt;
12474       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
12475
12476       /* Initialize the Paging Message members */
12477       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12478       if(paging->protocolIEs.list.array == NULLP)
12479       {
12480          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
12481          break;
12482       }
12483
12484       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12485       {
12486          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12487          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
12488          {
12489             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12490             memAllocFailed = true;
12491             break;
12492          }
12493       }
12494
12495       if(memAllocFailed == true)
12496       {
12497          break;
12498       }
12499
12500       /* UE Identity Index Value */
12501       ieIdx=0;
12502       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
12503       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12504       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
12505       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
12506       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
12507       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12508             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12509       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
12510       {
12511          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12512          break;
12513       }
12514
12515       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
12516       ueId = gsTmsi % 1024;
12517       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
12518
12519       /* Paging Identity */
12520       ieIdx++;
12521       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
12522       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12523       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
12524       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
12525                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
12526       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
12527             sizeof(struct CNUEPagingIdentity));
12528       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12529       {
12530          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12531          break;
12532       }
12533
12534       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
12535                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
12536
12537       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
12538       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12539             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12540       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
12541       {
12542          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12543          break;
12544       }
12545
12546       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
12547             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
12548
12549       /* Paging Drx */
12550       ieIdx++;
12551       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
12552       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12553       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
12554       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
12555
12556       /* Paging Priority */
12557       ieIdx++;
12558       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
12559       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12560       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
12561       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
12562
12563       /* Paging Cell List */
12564       ieIdx++;
12565       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
12566       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12567       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
12568       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
12569       {
12570          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
12571          break;
12572       }
12573
12574       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12575
12576       /* Encode the UE Context Release Command type as APER */
12577       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12578       encBufSize = 0;
12579       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12580             encBuf);
12581
12582       /* Encode results */
12583       if(encRetVal.encoded == ENCODE_FAIL)
12584       {
12585          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
12586                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12587          break;
12588       }
12589       else
12590       {
12591          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
12592          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12593          {
12594             DU_LOG("%x",encBuf[ieIdx]);
12595          }
12596       }
12597
12598       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
12599       {
12600          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
12601          break;
12602       }
12603
12604       ret = ROK;
12605       break;
12606
12607    }
12608
12609    FreePagingMsg(f1apMsg);
12610    return ret;
12611 }
12612
12613 /*******************************************************************
12614  *
12615  * @brief Decode received character string into F1AP message
12616  *
12617  * @details
12618  *
12619  *    Function : F1APMsgHdlr
12620  *
12621  *    Functionality:
12622  *         - Decodes received F1AP control message
12623  *
12624  * @params[in]
12625  * @return ROK     - success
12626  *         RFAILED - failure
12627  *
12628  * ****************************************************************/
12629 uint8_t F1APDecodeMsg(F1AP_PDU_t *f1apMsg, Buffer *mBuf, char **recvBuf, MsgLen *recvBufLen)
12630 {
12631    int i;
12632    MsgLen copyCnt;
12633    asn_dec_rval_t rval; /* Decoder return value */
12634
12635    /* Copy mBuf into char array to decode it */
12636    ODU_GET_MSG_LEN(mBuf, recvBufLen);
12637    CU_ALLOC(*recvBuf, (Size)(*recvBufLen));
12638    if(*recvBuf == NULLP)
12639    {
12640       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12641       return RFAILED;
12642    }
12643    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, *recvBufLen, (Data *)*recvBuf, &copyCnt) != ROK)
12644    {
12645       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12646       return RFAILED;
12647    }
12648
12649    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : \n");
12650    for(i=0; i< *recvBufLen; i++)
12651    {
12652       DU_LOG("%x ",(*recvBuf)[i]);
12653    }
12654
12655    /* Decoding flat buffer into F1AP messsage */
12656    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, *recvBuf, *recvBufLen, 0, 0);
12657    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12658    {
12659       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12660       return RFAILED;
12661    }
12662
12663    /* Printing the decoded F1AP PDU */
12664    DU_LOG("\n");
12665    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12666    return ROK;
12667 }
12668
12669 /*******************************************************************
12670  *
12671  * @brief Handles received F1AP message and sends back response
12672  *
12673  * @details
12674  *
12675  *    Function : F1APMsgHdlr
12676  *
12677  *    Functionality:
12678  *         - Decodes received F1AP control message
12679  *         - Prepares response message, encodes and sends to SCTP
12680  *
12681  * @params[in]
12682  * @return ROK     - success
12683  *         RFAILED - failure
12684  *
12685  * ****************************************************************/
12686 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12687 {
12688    char *recvBuf;
12689    MsgLen recvBufLen;
12690    F1AP_PDU_t *f1apMsg = NULLP;
12691    F1AP_PDU_t f1apasnmsg ;
12692
12693    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12694    ODU_PRINT_MSG(mBuf, 0,0);
12695
12696    f1apMsg = &f1apasnmsg;
12697    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12698    if(F1APDecodeMsg(f1apMsg, mBuf, &recvBuf, &recvBufLen) != ROK)
12699    {
12700       DU_LOG("\nERROR  -->  F1AP : F1AP PDU decode failed");
12701       return;
12702    }
12703
12704    switch(f1apMsg->present)
12705    {
12706       case F1AP_PDU_PR_initiatingMessage:
12707          {
12708             switch(f1apMsg->choice.initiatingMessage->value.present)
12709             {
12710                case InitiatingMessage__value_PR_Reset:
12711                   {
12712                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12713                      BuildAndSendF1ResetAck();
12714                      break;
12715                   }
12716
12717                case InitiatingMessage__value_PR_F1SetupRequest:
12718                   {
12719                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12720                      procF1SetupReq(duId, f1apMsg);
12721                      break;
12722                   }
12723
12724                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12725                   {
12726                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12727                      procGnbDuUpdate(*duId, f1apMsg);
12728                      break;
12729                   }
12730                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12731                   {
12732                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12733                      procInitULRRCMsg(*duId, f1apMsg);
12734                      break;
12735                   }
12736                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12737                   {
12738                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12739                      procUlRrcMsg(*duId, f1apMsg);
12740                      break;
12741                   }
12742
12743                case InitiatingMessage__value_PR_RRCDeliveryReport:
12744                   {
12745                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12746                      break;
12747                   }
12748                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12749                   {
12750                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12751                      procUeContextReleaseReq(*duId, f1apMsg);
12752                      break;
12753                   }
12754                default:
12755                   {
12756                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12757                            f1apMsg->choice.initiatingMessage->value.present);
12758                      return;
12759                   }
12760             }/* End of switch(initiatingMessage) */
12761             break;
12762          }
12763
12764       case F1AP_PDU_PR_successfulOutcome:
12765          {
12766             switch(f1apMsg->choice.successfulOutcome->value.present)
12767             {
12768                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12769                   {
12770                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12771                      break;
12772                   }
12773                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12774                   {
12775                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12776                      procUeContextSetupResponse(*duId, f1apMsg, recvBuf, recvBufLen);
12777                      break;
12778                   }
12779                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12780                   {
12781                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12782                      procUeContextModificationResponse(*duId, f1apMsg, recvBuf, recvBufLen);
12783                      break;
12784                   }
12785                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12786                   {
12787                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12788                       procUeContextReleaseComplete(*duId, f1apMsg);
12789                       break;
12790                   }
12791                default:
12792                   {
12793                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12794                            f1apMsg->choice.successfulOutcome->value.present);
12795                      return;
12796                   }
12797             }/* End of switch(successfulOutcome) */
12798             break;
12799          }
12800       default:
12801          {
12802             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12803             return;
12804          }
12805    }/* End of switch(f1apMsg->present) */
12806
12807    CU_FREE(recvBuf, (Size)(recvBufLen));
12808 } /* End of F1APMsgHdlr */
12809
12810 /**********************************************************************
12811   End of file
12812  **********************************************************************/