src/cu_stub/cu_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "ProtocolIE-Field.h"
  25 #include "ProtocolExtensionField.h"
  26 #include "ProtocolIE-SingleContainer.h"
  27 #include "F1SetupResponse.h"
  28 #include "SuccessfulOutcome.h"
  29 #include "InitiatingMessage.h"
  30 #include "NonDynamic5QIDescriptor.h"
  31 #include "AveragingWindow.h"
  32 #include "MaxDataBurstVolume.h"
  33 #include "Flows-Mapped-To-DRB-Item.h"
  34 #include "SliceSupportItem.h"
  35 #include "ServedPLMNs-Item.h"
  36 #include "F1AP-PDU.h"
  37 #include "ULUPTNLInformation-ToBeSetup-Item.h"
  38 #include "ULConfiguration.h"
  39 #include "ModulationOrder.h"
  40 #include "BandNR.h"
  41 #include "UE-CapabilityRAT-Container.h"
  42 #include "UE-CapabilityRAT-ContainerList.h"
  43 #include "UE-CapabilityRAT-ContainerListRRC.h"
  44 #include "HandoverPreparationInformationRrc-IEs.h"
  45 #include "HandoverPreparationInformationRrc.h"
  46 #include "SupportedBandwidth.h"
  47 #include "FeatureSetUplinkPerCC.h"
  48 #include "FeatureSetDownlinkPerCC.h"
  49 #include "FeatureSets.h"
  50 #include "RF-Parameters.h"
  51 #include "UE-NR-Capability.h"
  52 #include "ProtocolExtensionContainer.h"
  53 #include "CellGroupConfigRrc.h"
  54 #include "MAC-CellGroupConfig.h"
  55 #include "SchedulingRequestConfig.h"
  56 #include "SchedulingRequestToAddMod.h"
  57 #include "BSR-Config.h"
  58 #include "TAG-Config.h"
  59 #include "TAG.h"
  60 #include "PHR-Config.h"
  61 #include "RLC-Config.h"
  62 #include "UL-AM-RLC.h"
  63 #include "DL-AM-RLC.h"
  64 #include "LogicalChannelConfig.h"
  65 #include "RLC-BearerConfig.h"
  66 #include "PhysicalCellGroupConfig.h"
  67 #include "SpCellConfig.h"
  68 #include "ServingCellConfig.h"
  69 #include "ControlResourceSet.h"
  70 #include "SearchSpace.h"
  71 #include "PDCCH-Config.h"
  72 #include "PDSCH-TimeDomainResourceAllocation.h"
  73 #include "PDSCH-TimeDomainResourceAllocationList.h"
  74 #include "DMRS-DownlinkConfig.h"
  75 #include "PDSCH-Config.h"
  76 #include "BWP-DownlinkDedicated.h"
  77 #include "PUSCH-TimeDomainResourceAllocation.h"
  78 #include "PUSCH-TimeDomainResourceAllocationList.h"
  79 #include "DMRS-UplinkConfig.h"
  80 #include "PUSCH-Config.h"
  81 #include "SRS-ResourceId.h"
  82 #include "SRS-Resource.h"
  83 #include "SRS-ResourceSet.h"
  84 #include "SRS-Config.h"
  85 #include "PUCCH-Config.h"
  86 #include "PUCCH-ResourceSet.h"
  87 #include "PUCCH-Resource.h"
  88 #include "PUCCH-format1.h"
  89 #include "PUCCH-FormatConfig.h"
  90 #include "BWP-UplinkDedicated.h"
  91 #include "PUSCH-ServingCellConfig.h"
  92 #include "UplinkConfig.h"
  93 #include "PDSCH-ServingCellConfig.h"
  94 #include "EUTRANQoS.h"
  95 #include "GBR-QosInformation.h"
  96 #include "DRBs-ToBeSetupMod-List.h"
  97 #include "DRBs-ToBeSetupMod-Item.h"
  98 #include "DRBs-Setup-Item.h"
  99 #include "DLUPTNLInformation-ToBeSetup-List.h"
 100 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 101 #include "UPTransportLayerInformation.h"
 102 #include "GTPTunnel.h"
 103 #include "QoSInformation.h"
 104 #include "Cells-to-be-Activated-List.h"
 105 #include "DL-CCCH-Message.h"
 106 #include "SRB-ToAddModList.h"
 107 #include "SRB-ToAddMod.h"
 108 #include "RRCSetup-IEs.h"
 109 #include "RRCSetup.h"
 110 #include "DL-DCCH-Message.h"
 111 #include "RRCReconfiguration-IEs.h"
 112 #include "RRCReconfiguration.h"
 113 #include "DRB-ToAddModList.h"
 114 #include "DRB-ToAddMod.h"
 115 #include "SDAP-Config.h"
 116 #include "SSB-MTC.h"
 117 #include "MeasTiming.h"
 118 #include "MeasTimingList.h"
 119 #include "MeasurementTimingConfigurationRrc-IEs.h"
 120 #include "MeasurementTimingConfigurationRrc.h"
 121 #include "PDCP-Config.h"
 122 #include "RSRP-Range.h"
 123 #include "RSRQ-Range.h"
 124 #include "SINR-Range.h"
 125 #include "ThresholdNR.h"
 126 #include "MeasObjectToAddMod.h"
 127 #include "MeasObjectNR.h"
 128 #include "MeasObjectToAddModList.h"
 129 #include "EventTriggerConfig.h"
 130 #include "ReportConfigNR.h"
 131 #include "ReportConfigToAddMod.h"
 132 #include "ReportConfigToAddModList.h"
 133 #include "MeasIdToAddMod.h"
 134 #include "MeasIdToAddModList.h"
 135 #include "FilterCoefficient.h"
 136 #include "QuantityConfigNR.h"
 137 #include "QuantityConfig.h"
 138 #include "MeasConfigRrc.h"
 139 #include "AS-Config.h"
 140 #include "RRCReconfiguration-v1530-IEs.h"
 141 #include "CNUEPagingIdentity.h"
 142 #include "PagingCell-Item.h"
 143 #include "UL-DCCH-Message.h"
 144 #include "DRX-ConfigRrc.h"
 145
 146 #include "cu_stub_sctp.h"
 147 #include "cu_stub_egtp.h"
 148 #include "cu_f1ap_msg_hdl.h"
 149 #include "cu_stub.h"
 150
 151 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 152 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 153
 154 /*******************************************************************
 155  *
 156  * @brief Sends F1 msg over SCTP
 157  *
 158  * @details
 159  *
 160  *    Function : SendF1APMsg
 161  *
 162  *    Functionality: Sends F1 msg over SCTP
 163  *
 164  * @params[in] Region region
 165  *             Pool pool
 166  * @return ROK     - success
 167  *         RFAILED - failure
 168  *
 169  * ****************************************************************/
 170 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 171 {
 172    Buffer *mBuf = NULLP;
 173
 174    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 175    {
 176       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 177       {
 178          ODU_PRINT_MSG(mBuf, 0,0);
 179
 180          if(sctpSend(duId, mBuf) != ROK)
 181          {
 182             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 183             ODU_PUT_MSG_BUF(mBuf);
 184             return RFAILED;
 185          }
 186       }
 187       else
 188       {
 189          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 190          ODU_PUT_MSG_BUF(mBuf);
 191          return RFAILED;
 192       }
 193       ODU_PUT_MSG_BUF(mBuf);
 194    }
 195    else
 196    {
 197       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 198       return RFAILED;
 199    }
 200
 201    return ROK;
 202 } /* SendF1APMsg */
 203
 204 /********************************************************************
 205  *
 206  * @brief Builds and sends the F1SetupResponse
 207  *
 208  * @details
 209  *
 210  *    Function : BuildAndSendF1SetupRsp
 211  *
 212  *    Functionality: Constructs the F1SetupResponse message and sends
 213  *                   it back to the DU through SCTP.
 214  *
 215  * @params[in] void **buf,Buffer to which encoded pattern is written into
 216  * @params[in] int *size,size of buffer
 217  *
 218  * @return ROK     - success
 219  *         RFAILED - failure
 220  *
 221  * ****************************************************************/
 222 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 223 {
 224    uint8_t    idx,ieIdx;
 225    uint8_t    elementCnt,cellCnt;
 226    F1AP_PDU_t         *f1apMsg = NULL;
 227    F1SetupResponse_t  *f1SetupRsp = NULL;
 228    GNB_CU_Name_t      *cuName = NULL;
 229    Cells_to_be_Activated_List_t *cellToActivate;
 230    RRC_Version_t      *rrcVer = NULL;
 231    asn_enc_rval_t     encRetVal;
 232    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 233
 234    /* Allocate the memory for F1SetupRequest_t */
 235    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 236    if(f1apMsg == NULLP)
 237    {
 238       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 239       return RFAILED;
 240    }
 241    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 242
 243    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 244    if(f1apMsg->choice.successfulOutcome == NULLP)
 245    {
 246       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 247       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 248       return RFAILED;
 249    }
 250
 251    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 252    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 253    f1apMsg->choice.successfulOutcome->value.present = \
 254                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 255    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 256
 257    elementCnt = 3;
 258    f1SetupRsp->protocolIEs.list.count = elementCnt;
 259    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 260
 261    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 262          elementCnt * sizeof(F1SetupResponseIEs_t *));
 263    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 264    {
 265       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 266       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 267       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 268       return RFAILED;
 269    }
 270
 271    for(idx=0; idx<elementCnt; idx++)
 272    {
 273       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 274             sizeof(F1SetupResponseIEs_t));
 275       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 276       {
 277          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 278                elementCnt * sizeof(F1SetupResponseIEs_t *));
 279          CU_FREE(f1apMsg->choice.successfulOutcome, \
 280                sizeof(SuccessfulOutcome_t));
 281          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 282          return RFAILED;
 283       }
 284    }
 285
 286    /*TransactionID*/
 287    idx = 0;
 288    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 289    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 290    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 291                                                             F1SetupResponseIEs__value_PR_TransactionID;
 292    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 293                                                                         TRANS_ID;
 294 #if 0
 295    /* CU name IE is of type printableString_t which wireshark is unable to decode.
 296     * However this string is decoded successfully on online decoders.
 297     * Since this is an optional IE and the value received in it are not
 298     * used as of now, eliminating this IE for now to avoid wireshark error.
 299     */
 300    /*CU Name*/
 301    idx++;
 302    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 303    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 304    f1SetupRsp->protocolIEs.list.array[idx]->value.present = F1SetupResponseIEs__value_PR_GNB_CU_Name;
 305    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 306    cuName->size = strlen((char *)cuCb.cuCfgParams.cuName);
 307
 308    CU_ALLOC(cuName->buf, cuName->size);
 309    if(cuName->buf == NULLP)
 310    {
 311       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 312       {
 313          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 314       }
 315       CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 316       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 317       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 318       return RFAILED;
 319    }
 320    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 321 #endif
 322
 323    /*Cells to be activated list*/
 324    idx++;
 325    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 326    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 327    f1SetupRsp->protocolIEs.list.array[idx]->value.present = F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 328    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.Cells_to_be_Activated_List;
 329
 330    cellCnt=1;
 331    cellToActivate->list.count = cellCnt;
 332    cellToActivate->list.size = cellCnt * sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 333    CU_ALLOC(cellToActivate->list.array, sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 334    if(cellToActivate->list.array == NULLP)
 335    {
 336       CU_FREE(cuName->buf, sizeof(cuName->size));
 337       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 338       {
 339          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 340       }
 341       CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 342       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 343       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 344       return RFAILED;
 345    }
 346    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 347    {
 348       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 349       if(cellToActivate->list.array[ieIdx] == NULLP)
 350       {
 351          CU_FREE(cellToActivate->list.array, sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 352          CU_FREE(cuName->buf, sizeof(cuName->size));
 353          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 354          {
 355             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], sizeof(F1SetupResponseIEs_t));
 356          }
 357          CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 358          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 359          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 360          return RFAILED;
 361       }
 362    }
 363    cellToActivate->list.array[0]->id = \
 364                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 365    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 366    cellToActivate->list.array[0]->value.present = \
 367                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 368    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 369       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 370    CU_ALLOC(cellToActivate->list.array[0]->\
 371          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 372          3*sizeof(uint8_t));
 373    if(cellToActivate->list.array[0]->value.choice.\
 374          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 375    {
 376
 377       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 378       {
 379          CU_FREE(cellToActivate->list.array[ieIdx],\
 380                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 381       }
 382
 383       CU_FREE(cellToActivate->list.array,\
 384             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 385       CU_FREE(cuName->buf, sizeof(cuName->size));
 386       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 387       {
 388          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 389                sizeof(F1SetupResponseIEs_t));
 390       }
 391       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 392             elementCnt * sizeof(F1SetupResponseIEs_t *));
 393       CU_FREE(f1apMsg->choice.successfulOutcome, \
 394             sizeof(SuccessfulOutcome_t));
 395       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 396       return RFAILED;
 397    }
 398    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 399          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 400    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 401       nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
 402    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 403          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 404          cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 405          nRCGI.nRCellIdentity.size);
 406    if(cellToActivate->list.array[0]->value.choice.\
 407          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 408    {
 409       CU_FREE(cellToActivate->list.array[0]->\
 410             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 411             3*sizeof(uint8_t));
 412       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 413       {
 414          CU_FREE(cellToActivate->list.array[ieIdx],\
 415                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 416       }
 417
 418       CU_FREE(cellToActivate->list.array,\
 419             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 420       CU_FREE(cuName->buf, sizeof(cuName->size));
 421       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 422       {
 423          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 424                sizeof(F1SetupResponseIEs_t));
 425       }
 426       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 427             elementCnt * sizeof(F1SetupResponseIEs_t *));
 428       CU_FREE(f1apMsg->choice.successfulOutcome, \
 429             sizeof(SuccessfulOutcome_t));
 430       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 431       return RFAILED;
 432    }
 433    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 434
 435    /* RRC Version */
 436    idx++;
 437    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 438                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 439    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 440    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 441                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 442    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 443    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 444
 445    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 446    if(rrcVer->latest_RRC_Version.buf == NULLP)
 447    {
 448       CU_FREE(cuName->buf, sizeof(cuName->size));
 449       for(ieIdx=0; ieIdx<elementCnt; idx++)
 450       {
 451          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 452                sizeof(F1SetupResponseIEs_t));
 453       }
 454       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 455             elementCnt * sizeof(F1SetupResponseIEs_t *));
 456       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 457       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 458       return RFAILED;
 459    }
 460
 461    /* Need to check RRC Version */
 462    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 463    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 464    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 465    if(rrcVer->iE_Extensions == NULLP)
 466    {
 467       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 468       CU_FREE(cuName->buf, sizeof(cuName->size));
 469       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 470       {
 471          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 472                sizeof(F1SetupResponseIEs_t));
 473       }
 474       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 475             elementCnt * sizeof(F1SetupResponseIEs_t *));
 476       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 477       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 478       return RFAILED;
 479    }
 480    rrcVer->iE_Extensions->list.count = 1;
 481    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 482    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 483          sizeof(struct RRC_Version_ExtIEs *));
 484    if(rrcVer->iE_Extensions->list.array == NULLP)
 485    {
 486       CU_FREE(rrcVer->iE_Extensions,\
 487             sizeof(ProtocolExtensionContainer_4624P81_t));
 488       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 489       CU_FREE(cuName->buf, sizeof(cuName->size));
 490       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 491       {
 492          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 493                sizeof(F1SetupResponseIEs_t));
 494       }
 495       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 496             elementCnt * sizeof(F1SetupResponseIEs_t *));
 497       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 498       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 499       return RFAILED;
 500    }
 501    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 502          sizeof(struct RRC_Version_ExtIEs));
 503    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 504    {
 505       CU_FREE(rrcVer->iE_Extensions->list.array,\
 506             sizeof(struct RRC_Version_ExtIEs *));
 507       CU_FREE(rrcVer->iE_Extensions,\
 508             sizeof(ProtocolExtensionContainer_4624P81_t));
 509       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 510       CU_FREE(cuName->buf, sizeof(cuName->size));
 511       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 512       {
 513          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 514                sizeof(F1SetupResponseIEs_t));
 515       }
 516       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 517             elementCnt * sizeof(F1SetupResponseIEs_t *));
 518       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 519       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 520       return RFAILED;
 521    }
 522    rrcVer->iE_Extensions->list.array[0]->id = \
 523                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 524    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 525    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 526                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 527    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 528       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 529    CU_ALLOC(rrcVer->iE_Extensions->list.\
 530          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 531          3*sizeof(uint8_t));
 532    if(rrcVer->iE_Extensions->list.\
 533          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 534    {
 535       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 536             sizeof(struct RRC_Version_ExtIEs));
 537       CU_FREE(rrcVer->iE_Extensions->list.array,\
 538             sizeof(struct RRC_Version_ExtIEs *));
 539       CU_FREE(rrcVer->iE_Extensions,\
 540             sizeof(ProtocolExtensionContainer_4624P81_t));
 541       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 542       CU_FREE(cuName->buf, sizeof(cuName->size));
 543       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 544       {
 545          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 546                sizeof(F1SetupResponseIEs_t));
 547       }
 548       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 549             elementCnt * sizeof(F1SetupResponseIEs_t *));
 550       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 551       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 552       return RFAILED;
 553    }
 554    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 555       Latest_RRC_Version_Enhanced.buf[0] = 0;
 556    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 557       Latest_RRC_Version_Enhanced.buf[1] = 5;
 558    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 559       Latest_RRC_Version_Enhanced.buf[2] = 15;
 560
 561    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 562
 563    /* Encode the F1SetupRequest type as UPER */
 564    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 565    encBufSize = 0;
 566    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 567
 568    /* Clean up */
 569    if(rrcVer)
 570       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 571    if(cuName)
 572       CU_FREE(cuName->buf, cuName->size);
 573    for(idx=0; idx<elementCnt; idx++)
 574    {
 575       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 576    }
 577    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 578    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 579    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 580
 581    /* Check encode results */
 582    if(encRetVal.encoded == ENCODE_FAIL)
 583    {
 584       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 585             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 586       return RFAILED;
 587    }
 588    else
 589    {
 590       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 591       for(int i=0; i< encBufSize; i++)
 592       {
 593          DU_LOG("%x",encBuf[i]);
 594       }
 595    }
 596
 597    /* Sending msg */
 598    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 599    {
 600       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 601       return RFAILED;
 602    }
 603
 604    return ROK;
 605 }/* End of BuildAndSendF1SetupRsp */
 606
 607 /*******************************************************************
 608  *
 609  * @brief Builds and sends the DUUpdateAcknowledge
 610  *
 611  * @details
 612  *
 613  *    Function : BuildAndSendDUUpdateAck
 614  *
 615  *    Functionality: Constructs the DU Update Acknowledge message and sends
 616  *                   it to the DU through SCTP.
 617  *
 618  * @params[in]
 619  *
 620  * @return ROK     - success
 621  *         RFAILED - failure
 622  *
 623  * ****************************************************************/
 624
 625 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 626 {
 627    uint8_t   idx;
 628    uint8_t   elementCnt;
 629    F1AP_PDU_t *f1apMsg = NULL;
 630    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 631    asn_enc_rval_t enRetVal; /* Encoder return value */
 632
 633    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 634
 635    /* Allocate the memory for F1SetupRequest_t */
 636    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 637    if(f1apMsg == NULLP)
 638    {
 639       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 640       return RFAILED;
 641    }
 642
 643    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 644
 645    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 646    if(f1apMsg->choice.successfulOutcome == NULLP)
 647    {
 648       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 649       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 650       return RFAILED;
 651    }
 652
 653    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 654    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 655    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 656    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 657
 658    elementCnt = 1;
 659    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 660    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 661
 662    /* Initialize the F1Setup members */
 663    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 664    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 665    {
 666       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 667       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 668       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 669       return RFAILED;
 670    }
 671
 672    for(idx=0; idx<elementCnt; idx++)
 673    {
 674       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 675       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 676       {
 677          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 678          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 679          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 680          return RFAILED;
 681       }
 682    }
 683
 684    /*TransactionID*/
 685    idx = 0;
 686    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 687    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 688    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 689    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 690    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 691
 692    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 693
 694    /* Encode the F1SetupRequest type as UPER */
 695    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 696    encBufSize = 0;
 697    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 698
 699    /* Clean up */
 700    for(idx=0; idx<elementCnt; idx++)
 701    {
 702       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 703    }
 704    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 705    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 706    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 707
 708    /* Checking encode results */
 709    if(enRetVal.encoded == ENCODE_FAIL)
 710    {
 711       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 712       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 713       return RFAILED;
 714    }
 715    else
 716    {
 717       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 718       for(int i=0; i< encBufSize; i++)
 719       {
 720          DU_LOG("%x",encBuf[i]);
 721       }
 722    }
 723
 724    /* Sending msg */
 725    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 726    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 727    {
 728       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 729       return RFAILED;
 730    }
 731
 732    return ROK;
 733
 734 }/* End of BuildAndSendDUUpdateAck*/
 735
 736 /*******************************************************************
 737 *
 738 * @brief deallocating the memory of  F1reset msg
 739 *
 740 * @details
 741 *
 742 *    Function : FreeF1ResetReq
 743 *
 744 *    Functionality :
 745 *         - freeing memory of F1reset request msg
 746 *
 747 * @params[in]
 748 * @return void
 749 *
 750 *
 751 * ****************************************************************/
 752 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 753 {
 754    uint8_t idx = 0;
 755    Reset_t *f1ResetMsg = NULLP;
 756
 757    if(f1apMsg)
 758    {
 759       if(f1apMsg->choice.initiatingMessage)
 760       {
 761          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 762          if(f1ResetMsg->protocolIEs.list.array)
 763          {
 764             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 765             {
 766                if(f1ResetMsg->protocolIEs.list.array[idx])
 767                {
 768                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 769                }
 770             }
 771             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 772          }
 773          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 774       }
 775       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 776    }
 777 }
 778 /*******************************************************************
 779  *
 780  * @brief build ansld ans send f1reset msg
 781  *
 782  * @details
 783  *
 784  *    Function : BuildAndSendF1ResetReq
 785  *
 786  *    Functionality: build and send f1reset msg
 787  *
 788  * @return ROK     - success
 789  *         RFAILED - failure
 790  *
 791  * ****************************************************************/
 792 uint8_t BuildAndSendF1ResetReq()
 793 {
 794    uint8_t          elementCnt=0;
 795    uint8_t          idx=0;
 796    uint8_t          ret= RFAILED;
 797    Reset_t          *f1ResetMsg = NULLP;
 798    F1AP_PDU_t       *f1apMsg = NULLP;
 799    asn_enc_rval_t   encRetVal;
 800    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 801    do
 802    {
 803       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 804       if(f1apMsg == NULLP)
 805       {
 806          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 807          break;
 808       }
 809       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 810       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 811       if(f1apMsg->choice.initiatingMessage == NULLP)
 812       {
 813          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 814          break;
 815       }
 816       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 817       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 818       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 819
 820       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 821
 822       elementCnt = 3;
 823       f1ResetMsg->protocolIEs.list.count = elementCnt;
 824       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 825
 826       /* Initialize the F1Reset members */
 827       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 828       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 829       {
 830          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 831          break;
 832       }
 833       for(idx=0; idx<elementCnt; idx++)
 834       {
 835          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 836          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 837          {
 838             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 839             break;
 840          }
 841       }
 842
 843       /*TransactionID*/
 844       idx=0;
 845       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 846       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 847       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 848       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 849
 850       /*Cause*/
 851       idx++;
 852       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 853       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 854       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 855       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 856       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 857
 858       /*Reset Type*/
 859       idx++;
 860       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 861       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 862       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 863       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 864       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 865
 866       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 867
 868       /* Encode the F1SetupRequest type as APER */
 869       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 870       encBufSize = 0;
 871       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 872             encBuf);
 873
 874       /* Encode results */
 875       if(encRetVal.encoded == ENCODE_FAIL)
 876       {
 877          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 878                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 879          break;
 880       }
 881       else
 882       {
 883          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 884          for(idx=0; idx< encBufSize; idx++)
 885          {
 886             DU_LOG("%x",encBuf[idx]);
 887          }
 888       }
 889
 890       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 891       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 892       {
 893          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 894          break;
 895       }
 896
 897       ret = ROK;
 898       break;
 899    }while(true);
 900
 901    FreeF1ResetReq(f1apMsg);
 902    return ret;
 903 }
 904
 905 /*******************************************************************
 906  *
 907  * @brief Fills Radio Bearer Config
 908  *
 909  * @details
 910  *
 911  *    Function : fillSrbCfg
 912  *
 913  *    Functionality: Fills Radio Bearer Config
 914  *
 915  * @params[in] SRB_ToAddModList *
 916  *
 917  * @return ROK     - success
 918  *         RFAILED - failure
 919  *
 920  * ****************************************************************/
 921 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 922 {
 923    uint8_t elementCnt = 0;
 924    uint8_t idx, ieId, srbIdx = 0;
 925
 926    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 927    {
 928       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 929          elementCnt++;
 930    }
 931
 932    if(bearerCfg != NULLP)
 933    {
 934       bearerCfg->list.count = elementCnt;
 935       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 936       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 937       if(bearerCfg->list.array != NULLP)
 938       {
 939          for(idx = 0; idx < elementCnt; idx++)
 940          {
 941             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 942             if(bearerCfg->list.array[idx] == NULLP)
 943             {
 944                for(ieId = 0; ieId < idx; ieId++)
 945                {
 946                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 947                }
 948                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 949                return RFAILED;
 950             }
 951          }
 952       }
 953       else
 954       {
 955          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 956          return RFAILED;
 957       }
 958
 959       idx = 0;
 960       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 961       {
 962          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 963             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 964       }
 965    }
 966    return ROK;
 967 }
 968
 969 /*******************************************************************
 970  *
 971  * @brief Fills Master CellGroup Info
 972  *
 973  * @details
 974  *
 975  *    Function : fillMasterCellGroup
 976  *
 977  *    Functionality: Fills Master Cell Group IE
 978  *
 979  * @params[in] RRCSetup_IEs_t *
 980  *
 981  * @return ROK     - success
 982  *         RFAILED - failure
 983  *
 984  * ****************************************************************/
 985
 986 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 987 {
 988    uint8_t ret = ROK;
 989    masterCellGroup->buf = NULLP;
 990    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 991    {
 992       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 993       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 994       if(masterCellGroup->buf != NULLP)
 995       {
 996          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
 997       }
 998       else
 999       {
1000          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
1001          ret = RFAILED;
1002       }
1003    }
1004    else
1005    {
1006       ret =  RFAILED;
1007    }
1008    return ret;
1009 }
1010
1011 /*******************************************************************
1012  *
1013  * @brief Fills RRC setup IE
1014  *
1015  * @details
1016  *
1017  *    Function : fillRRCSetupIE
1018  *
1019  *    Functionality: Fills RRC Setup IE
1020  *
1021  * @params[in] RRCSetup_IEs_t *
1022  *
1023  * @return ROK     - success
1024  *         RFAILED - failure
1025  *
1026  * ****************************************************************/
1027
1028 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1029 {
1030    uint8_t ret = ROK, srbIdx = 0;
1031    if(rrcSetupIE)
1032    {
1033       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1034       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1035       {
1036          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1037       }
1038       if(ret == ROK)
1039       {
1040          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1041       }
1042       else
1043       {
1044          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1045          ret = RFAILED;
1046       }
1047
1048       /* If SRB configuration are filled successfully in RRC Setup, mark these
1049        * configurartion as sent to UE */
1050       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1051       {
1052          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1053             ueCb->srbList[srbIdx].cfgSentToUe = true;
1054       }
1055    }
1056    return ret;
1057 }
1058 /*******************************************************************
1059  *
1060  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1061  *
1062  * @details
1063  *
1064  *    Function : fillDlCcchRrcMsg
1065  *
1066  *    Functionality: Fills DL DCCCH Message required for
1067  *                   DLRRCMessageTransfer
1068  *
1069  * @params[in] RRCContainer_t *rrcContainer
1070  *
1071  * @return ROK     - success
1072  *         RFAILED - failure
1073  *
1074  * ****************************************************************/
1075
1076 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1077 {
1078    uint8_t ret = ROK;
1079    uint16_t idx2;
1080    DL_CCCH_Message_t dl_CCCH_Msg;
1081    asn_enc_rval_t    encRetVal;
1082
1083    if(rrcContainer != NULLP)
1084    {
1085       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1086
1087       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1088       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1089       {
1090          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1091          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1092          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1093          {
1094             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1095             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1096                RRCSetup__criticalExtensions_PR_rrcSetup;
1097
1098             /* Fill RRC Setup IE */
1099             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1100                sizeof(RRCSetup_IEs_t));
1101             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1102             {
1103                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1104
1105                if(ret == ROK)
1106                {
1107                   /* encode DL-CCCH message into RRC Container */
1108                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1109                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1110                   encBufSize = 0;
1111                   encRetVal = uper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1112                   /* Encode results */
1113                   if(encRetVal.encoded == ENCODE_FAIL)
1114                   {
1115                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1116                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1117                      return RFAILED;
1118                   }
1119                   else
1120                   {
1121                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1122                      for(int i = 0; i< encBufSize; i++)
1123                      {
1124                         DU_LOG("%x",encBuf[i]);
1125                      }
1126                      rrcContainer->size = encBufSize;
1127                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1128                      if(rrcContainer->buf != NULLP)
1129                      {
1130                         memset(rrcContainer->buf, 0, encBufSize);
1131                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1132                         {
1133                            rrcContainer->buf[idx2] =    encBuf[idx2];
1134                         }
1135                      }
1136                   }
1137                }
1138                else
1139                {
1140                   ret = RFAILED;
1141                }
1142             }
1143             else
1144             {
1145                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1146                ret = RFAILED;
1147             }
1148          }
1149          else
1150          {
1151             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1152             ret = RFAILED;
1153          }
1154       }
1155       else
1156       {
1157          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1158          ret = RFAILED;
1159       }
1160    }
1161    else
1162    {
1163       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1164       ret = RFAILED;
1165    }
1166 }
1167
1168 /*******************************************************************
1169  *
1170  * @brief Fills QOS flow configuration
1171  *
1172  * @details
1173  *
1174  *    Function : fillQosFlowsToAdd
1175  *
1176  *    Functionality: Fills QOS flow configuration
1177  *
1178  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1179  *
1180  * @return ROK     - success
1181  *         RFAILED - failure
1182  *
1183  * ****************************************************************/
1184 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1185 {
1186    uint8_t idx, ied, elementCnt;
1187
1188    elementCnt = 1;
1189    qosFlow->list.count = elementCnt;
1190    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1191    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1192    if(qosFlow->list.array != NULLP)
1193    {
1194       for(idx = 0; idx < elementCnt; idx++)
1195       {
1196          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1197          if(qosFlow->list.array[idx] == NULLP)
1198          {
1199             for(ied = 0; ied < idx; ied++)
1200             {
1201                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1202             }
1203             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1204             return RFAILED;
1205          }
1206       }
1207    }
1208    idx = 0;
1209    *qosFlow->list.array[idx] = 9;
1210    return ROK;
1211 }
1212
1213 /*******************************************************************
1214  *
1215  * @brief Fills CN Assoc for Drb to Add/Mod List
1216  *
1217  * @details
1218  *
1219  *    Function : fillCnAssoc
1220  *
1221  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1222  *
1223  * @params[in] struct DRB_ToAddMod__cnAssociation *
1224  *
1225  * @return ROK     - success
1226  *         RFAILED - failure
1227  *
1228  * ****************************************************************/
1229
1230 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1231 {
1232    uint8_t ret = ROK;
1233
1234    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1235    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1236    {
1237       cnAssoc->choice.eps_BearerIdentity = 5;
1238    }
1239    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1240    {
1241       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1242       if(cnAssoc->choice.sdap_Config)
1243       {
1244          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1245          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1246          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1247          cnAssoc->choice.sdap_Config->defaultDRB = true;
1248          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1249          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1250          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1251                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1252          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1253          {
1254             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1255          }
1256          else
1257          {
1258             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1259             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1260             ret = RFAILED;
1261          }
1262       }
1263       else
1264       {
1265          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1266          ret = RFAILED;
1267       }
1268    }
1269    return ret;
1270 }
1271
1272 /*******************************************************************
1273  *
1274  * @brief Fills Radio Bearer Config for Drb
1275  *
1276  * @details
1277  *
1278  *    Function : fillDrbCfg
1279  *
1280  *    Functionality: Fills Radio Bearer Config for Drb
1281  *
1282  * @params[in] drbId, DRB_ToAddModList *
1283  *
1284  * @return ROK     - success
1285  *         RFAILED - failure
1286  *
1287  * ****************************************************************/
1288 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1289 {
1290    uint8_t idx, ied, ret, elementCnt;
1291
1292    ret = ROK;
1293    if(drbCfg != NULLP)
1294    {
1295       elementCnt = 1;
1296       drbCfg->list.count = elementCnt;
1297       drbCfg->list.size =\
1298                          elementCnt * sizeof(DRB_ToAddMod_t *);
1299       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1300       if(drbCfg->list.array != NULLP)
1301       {
1302          for(idx = 0; idx < elementCnt; idx++)
1303          {
1304             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1305             if(drbCfg->list.array[idx] == NULLP)
1306             {
1307                for(ied = 0; ied < idx; ied++)
1308                {
1309                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1310                }
1311                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1312                return RFAILED;
1313             }
1314          }
1315       }
1316       else
1317       {
1318          return RFAILED;
1319       }
1320       idx = 0;
1321       /* CN ASSOCIATION */
1322       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1323       if(drbCfg->list.array[idx]->cnAssociation)
1324       {
1325          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1326       }
1327       /* DRB */
1328       drbCfg->list.array[idx]->drb_Identity = drbId;
1329    }
1330    return ret;
1331 }
1332
1333 /*******************************************************************
1334  *
1335  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1336  *
1337  * @details
1338  *
1339  *    Function : fillRrcReconfigIE
1340  *
1341  *    Functionality: Fills RRC Reconfig Message required for
1342  *                   DLRRCMessageTransfer
1343  *
1344  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1345  *
1346  * @return ROK     - success
1347  *         RFAILED - failure
1348  *
1349  * ****************************************************************/
1350
1351 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1352 {
1353    uint8_t ret = ROK;
1354    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1355    if(rrcReconfigMsg->radioBearerConfig)
1356    {
1357       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1358       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1359       {
1360          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1361
1362       }
1363       if(ret == ROK)
1364       {
1365          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1366          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1367          {
1368             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1369             if(ret == RFAILED)
1370             {
1371                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1372                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1373                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1374             }
1375          }
1376       }
1377       else
1378       {
1379          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1380          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1381       }
1382    }
1383
1384    return ret;
1385 }
1386 /*******************************************************************
1387  *
1388  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1389  *
1390  * @details
1391  *
1392  *    Function : fillDlDcchRrcMsg
1393  *
1394  *    Functionality: Fills DL DCCH Message required for
1395  *                   DLRRCMessageTransfer
1396  *
1397  * @params[in] RRCContainer_t *rrcContainer
1398  *
1399  * @return ROK     - success
1400  *         RFAILED - failure
1401  *
1402  * ****************************************************************/
1403
1404 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer, bool updateAllRbCfg)
1405 {
1406    uint8_t ret = ROK;
1407    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1408    DL_DCCH_Message_t dl_DCCH_Msg;
1409    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1410    asn_enc_rval_t        encRetVal;
1411
1412    if(rrcContainer != NULLP)
1413    {
1414       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1415
1416       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1417       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1418       {
1419          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1420          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1421          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1422          {
1423             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1424             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, updateAllRbCfg);
1425             if(ret == ROK)
1426             {
1427                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1428                 * configurartion as sent to UE */
1429                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1430                {
1431                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1432                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1433                }
1434                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1435                {
1436                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1437                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1438                }
1439
1440                /* encode DL-DCCH message into RRC Container */
1441                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1442                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1443                encBufSize = 0;
1444                encRetVal = uper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1445                /* Encode results */
1446                if(encRetVal.encoded == ENCODE_FAIL)
1447                {
1448                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1449                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1450                   return RFAILED;
1451                }
1452                else
1453                {
1454                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1455                   for(int i = 0; i< encBufSize; i++)
1456                   {
1457                      DU_LOG("%x",encBuf[i]);
1458                   }
1459                   rrcContainer->size = encBufSize;
1460                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1461                   if(rrcContainer->buf != NULLP)
1462                   {
1463                      memset(rrcContainer->buf, 0, encBufSize);
1464                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1465                      {
1466                         rrcContainer->buf[idx2] =       encBuf[idx2];
1467                      }
1468                   }
1469                }
1470             }
1471          }
1472          else
1473          {
1474             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1475             ret = RFAILED;
1476          }
1477       }
1478       else
1479       {
1480          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1481          ret = RFAILED;
1482       }
1483    }
1484    else
1485    {
1486       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1487       ret = RFAILED;
1488    }
1489    return ret;
1490 }
1491
1492 /*******************************************************************
1493  *
1494  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1495  *
1496  * @details
1497  *
1498  *    Function : BuildDLRRCContainer
1499  *
1500  *    Functionality: Builds RRC Container IE required for
1501  *                   DLRRCMessageTransfer
1502  *
1503  * @params[in]
1504  *
1505  * @return ROK     - success
1506  *         RFAILED - failure
1507  *
1508  * ****************************************************************/
1509
1510 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1511 {
1512    uint8_t ret, bufLen;
1513
1514    ret =ROK;
1515    if(rrcMsgType == RRC_SETUP)
1516    {
1517       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1518       if(ret == RFAILED)
1519          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1520    }
1521    else if(rrcMsgType == RRC_SETUP_COMPLETE)
1522    {
1523       DU_LOG("\nINFO --> F1AP : Sending NAS Security mode command");
1524       char secModeBuf[30]={0x00, ueCb->pdcpSn++, 0x2e, 0x82, 0xaf, 0xc0, 0x7d, 0x1c, 0x4e, 0xfc, 0x80, 0x0f, 0xc0,
1525                           0x0b, 0xa0, 0x20, 0x40, 0x9e, 0x0e, 0x1e, 0x0e, 0x1c, 0x26, 0xc0, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00};
1526       bufLen =30;
1527       rrcContainer->size = bufLen;
1528       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1529       if(rrcContainer->buf != NULLP)
1530       {
1531          memset(rrcContainer->buf, 0, bufLen);
1532          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1533       }
1534       else
1535       {
1536          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1537          ret = RFAILED;
1538       }
1539    }
1540    else if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
1541    {
1542       DU_LOG("\nINFO --> F1AP : Sending RRC Security mode command");
1543       char secModeBuf[9]={0x00, ueCb->pdcpSn++, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1544       bufLen =9;
1545       rrcContainer->size = bufLen;
1546       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1547       if(rrcContainer->buf != NULLP)
1548       {
1549          memset(rrcContainer->buf, 0, bufLen);
1550          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1551       }
1552       else
1553       {
1554          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1555          ret = RFAILED;
1556       }
1557    }
1558    else if(rrcMsgType == RRC_SECURITY_MODE_COMPLETE)
1559    {
1560       /*Hardcoded RRC Container from reference logs*/
1561       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1562       char buf[14] ={0x00, ueCb->pdcpSn++, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1563       bufLen =14;
1564       rrcContainer->size = bufLen;
1565       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1566       if(rrcContainer->buf != NULLP)
1567       {
1568          memset(rrcContainer->buf, 0, bufLen);
1569          memcpy(rrcContainer->buf, buf, bufLen);
1570       }
1571       else
1572       {
1573          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1574          ret = RFAILED;
1575       }
1576    }
1577    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1578    {
1579       uint16_t tmpBufIdx = 0, bufIdx = 0;
1580       RRCContainer_t rrcContainerTmp;
1581       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1582       ret = fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, false);
1583       rrcContainer->size = rrcContainerTmp.size + 2;
1584       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1585       if(rrcContainer->buf != NULLP)
1586       {
1587          memset(rrcContainer->buf, 0, rrcContainer->size);
1588          rrcContainer->buf[0] = 0x00;
1589          rrcContainer->buf[1] = ueCb->pdcpSn++; //PDCP SN
1590          for(bufIdx = 2, tmpBufIdx = 0; bufIdx < rrcContainer->size; bufIdx++, tmpBufIdx++)
1591          {
1592             rrcContainer->buf[bufIdx] = rrcContainerTmp.buf[tmpBufIdx];
1593          }
1594       }
1595       if(ret == RFAILED)
1596          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1597    }
1598
1599    return ret;
1600 }
1601
1602 /*******************************************************************
1603  *
1604  * @brief Frees the DLRRCMessageTransfer
1605  *
1606  * @details
1607  *
1608  *    Function : freeDlRrcMessageTransfer
1609  *
1610  *    Functionality: Frees the DLRRCMessageTransfer
1611  *
1612  * @params[in]
1613  *
1614  * @return ROK     - success
1615  *         RFAILED - failure
1616  *
1617  * ****************************************************************/
1618 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1619 {
1620    uint8_t idx=0;
1621    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1622
1623    if(f1apMsg)
1624    {
1625       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1626       if(dlRRCMsg->protocolIEs.list.array)
1627       {
1628          idx = 3;
1629          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1630             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1631          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1632          {
1633             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1634          }
1635          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1636       }
1637       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1638    }
1639 }
1640
1641 /*******************************************************************
1642  *
1643  * @brief Builds and sends the DLRRCMessageTransfer
1644  *
1645  * @details
1646  *
1647  *    Function : BuildAndSendDLRRCMessageTransfer
1648  *
1649  *    Functionality: Constructs the DL RRC Message Transfer and sends
1650  *                   it to the CU through SCTP.
1651  *
1652  * @params[in]
1653  *
1654  * @return ROK     - success
1655  *         RFAILED - failure
1656  *
1657  * ****************************************************************/
1658 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1659 {
1660    uint8_t   elementCnt = 0;
1661    uint8_t  ieId;
1662    uint8_t  idx;
1663    F1AP_PDU_t  *f1apMsg = NULLP;
1664    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1665    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1666
1667    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1668
1669    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1670    if(f1apMsg == NULLP)
1671    {
1672       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1673       return RFAILED;
1674    }
1675
1676    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1677    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1678    if(f1apMsg->choice.initiatingMessage == NULLP)
1679    {
1680       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1681       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1682       return RFAILED;
1683    }
1684
1685    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1686    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1687    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1688    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1689
1690    elementCnt = 4;
1691    dlRRCMsg->protocolIEs.list.count = elementCnt;
1692    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1693
1694    /* Initialize the F1Setup members */
1695    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1696    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1697    {
1698       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1699       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1700       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1701       return RFAILED;
1702    }
1703
1704    for(idx=0; idx<elementCnt; idx++)
1705    {
1706       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1707       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1708       {
1709          for(ieId=0; ieId<idx; ieId++)
1710          {
1711             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1712          }
1713          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1714          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1715          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1716          return RFAILED;
1717       }
1718    }
1719
1720    /* GNB CU UE F1AP ID */
1721    idx = 0;
1722    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1723    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1724    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1725    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1726
1727    /* GNB DU UE F1AP ID */
1728    idx++;
1729    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1730    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1731    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1732    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1733
1734    /* SRBID */
1735    idx++;
1736    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1737    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1738    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1739    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1740
1741    /* RRCContainer */
1742    idx++;
1743    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1744    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1745    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1746    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1747
1748    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1749
1750    /* Encode the F1SetupRequest type as APER */
1751    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1752    encBufSize = 0;
1753    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1754          encBuf);
1755    /* Encode results */
1756    if(encRetVal.encoded == ENCODE_FAIL)
1757    {
1758       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1759             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1760       return RFAILED;
1761    }
1762    else
1763    {
1764       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1765       for(int i=0; i< encBufSize; i++)
1766       {
1767          DU_LOG("%x",encBuf[i]);
1768       }
1769    }
1770
1771    /* Sending  msg  */
1772    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1773    {
1774       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1775       return RFAILED;
1776    }
1777    freeDlRrcMessageTransfer(f1apMsg);
1778    return ROK;
1779 }/* End of BuildAndSendDLRRCMessageTransfer */
1780
1781 /*******************************************************************
1782  *
1783  * @brief Function to set the Dl RRC Msg Type
1784  *
1785  * @details
1786  *
1787  *    Function : setDlRRCMsgType
1788  *
1789  *    Functionality: Constructs the UE Setup Response and sends
1790  *                   it to the DU through SCTP.
1791  *
1792  * @params[in]
1793  *
1794  * @return ROK     - success
1795  *         RFAILED - failure
1796  *
1797  * ****************************************************************/
1798
1799 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1800 {
1801    uint8_t rrcMsgType = 0;
1802    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1803    {
1804       case RRC_SETUP:
1805          rrcMsgType = RRC_SETUP;
1806          break;
1807       case RRC_SETUP_COMPLETE:
1808          rrcMsgType = RRC_SETUP_COMPLETE;
1809          break;
1810       case NAS_SECURITY_MODE_COMPLETE:
1811          rrcMsgType = NAS_SECURITY_MODE_COMPLETE;
1812          break;
1813       case RRC_SECURITY_MODE_COMPLETE:
1814          rrcMsgType = RRC_SECURITY_MODE_COMPLETE;
1815          break;
1816       case REGISTRATION_COMPLETE:
1817          rrcMsgType = REGISTRATION_COMPLETE;
1818          break;
1819       case UE_CONTEXT_SETUP_RSP:
1820          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1821          break;
1822       case RRC_RECONFIG_COMPLETE:
1823          rrcMsgType = RRC_RECONFIG_COMPLETE;
1824          break;
1825       default:
1826          break;
1827    }
1828    return rrcMsgType;
1829 }
1830
1831 #ifdef NR_DRX
1832 /*******************************************************************
1833  *
1834  * @brief fill long cycle offset value of drx
1835  *
1836  * @details
1837  *
1838  *    Function : fillLongCycleOffsetValue
1839  *
1840  *    Functionality: fill long cycle offset value of drx
1841  *
1842  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
1843  * struct DRX_ConfigRrc__drx_LongCycleStartOffset recvedLongCycleOffsetVal
1844  *
1845  * @return ROK     - success
1846  *         RFAILED - failure
1847  *
1848  * ****************************************************************/
1849 void fillLongCycleOffsetValue(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset *recvedLongCycleOffsetVal)
1850 {
1851
1852    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = recvedLongCycleOffsetVal->present;
1853    switch(recvedLongCycleOffsetVal->present)
1854    {
1855       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
1856          {
1857             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10;
1858             break;
1859          }
1860       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
1861          {
1862             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms20;
1863             break;
1864          }
1865       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
1866          {
1867             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms32;
1868             break;
1869          }
1870       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
1871          {
1872             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms40;
1873             break;
1874          }
1875       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
1876          {
1877             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms60;
1878             break;
1879          }
1880       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
1881          {
1882             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms64;
1883             break;
1884          }
1885       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
1886          {
1887             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms70;
1888             break;
1889          }
1890       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
1891          {
1892             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms80;
1893             break;
1894          }
1895       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
1896          {
1897             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms128;
1898             break;
1899          }
1900       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
1901          {
1902             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms160;
1903             break;
1904          }
1905       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
1906          {
1907             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms256;
1908             break;
1909          }
1910       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
1911          {
1912             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms320;
1913             break;
1914          }
1915       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
1916          {
1917             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms512;
1918             break;
1919          }
1920       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
1921          {
1922             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms640;
1923             break;
1924          }
1925       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
1926          {
1927             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1024;
1928             break;
1929          }
1930       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
1931          {
1932             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1280;
1933             break;
1934          }
1935       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
1936          {
1937             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2048;
1938             break;
1939          }
1940       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
1941          {
1942             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2560;
1943             break;
1944          }
1945       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
1946          {
1947             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms5120;
1948             break;
1949          }
1950       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
1951          {
1952             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10240;
1953             break;
1954          }
1955       default :
1956          break;
1957    }
1958 }
1959
1960 /*******************************************************************
1961  *
1962  * @brief Extract configuration from DRX_ConfigRrc
1963  *    and store the drx configuration in UeCb
1964  *
1965  * @details
1966  *
1967  *    Function : storeDrxCfgInUeCb
1968  *
1969  *    Functionality: Store drx configuration in UeCb
1970  *
1971  * @params[in] (struct DRX_ConfigRrc *setup, DrxCfg *drxCfg)
1972  *
1973  * @return void
1974  * ****************************************************************/
1975 void storeDrxCfgInUeCb(struct DRX_ConfigRrc *drxSetup, DrxCfg *drxCfg)
1976 {
1977    switch(drxSetup->drx_onDurationTimer.present)
1978    {
1979       case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
1980          break;
1981       case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
1982          {
1983             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
1984             drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=drxSetup->drx_onDurationTimer.choice.milliSeconds;
1985             break;
1986          }
1987       case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
1988          {
1989             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
1990             drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = drxSetup->drx_onDurationTimer.choice.subMilliSeconds;
1991             break;
1992          }
1993    }
1994    fillLongCycleOffsetValue(&drxCfg->drxLongCycleStartOffset, &drxSetup->drx_LongCycleStartOffset);
1995    drxCfg->drxInactivityTimer = drxSetup->drx_InactivityTimer;
1996    drxCfg->drxHarqRttTimerDl = drxSetup->drx_HARQ_RTT_TimerDL;
1997    drxCfg->drxHarqRttTimerUl = drxSetup->drx_HARQ_RTT_TimerUL;
1998    drxCfg->drxRetransmissionTimerDl = drxSetup->drx_RetransmissionTimerDL;
1999    drxCfg->drxRetransmissionTimerUl = drxSetup->drx_RetransmissionTimerUL;
2000    drxCfg->drxSlotOffset = drxSetup->drx_SlotOffset;
2001    if(drxSetup->shortDRX)
2002    {
2003       drxCfg->shortDrxPres=true;
2004       drxCfg->shortDrx.drxShortCycle = drxSetup->shortDRX->drx_ShortCycle;
2005       drxCfg->shortDrx.drxShortCycleTimer = drxSetup->shortDRX->drx_ShortCycleTimer;
2006    }
2007    else
2008       drxCfg->shortDrxPres=false;
2009 }
2010 #endif
2011
2012 /*******************************************************************
2013  *
2014  * @brief Extract configuration from CellGroupConfig
2015  *
2016  * @details
2017  *
2018  *    Function : extractCellGroupConfig
2019  *
2020  *    Functionality: Extract configuration from CellGroupConfig
2021  *        and store in local database
2022  *
2023  * @params[in] UE control block
2024  *             Cell Group Config
2025  *
2026  * @return ROK     - success
2027  *         RFAILED - failure
2028  *
2029  * ****************************************************************/
2030 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
2031 {
2032    uint8_t rbIdx, srbIdx, drbIdx;
2033    bool    srbFound, drbFound;
2034    SrbInfo *srbCfgDb = NULLP;
2035    DrbInfo *drbCfgDb = NULLP;
2036    RlcLcCfg *rlcLcCfgDb = NULLP;
2037    MacLcCfg *macLcCfgDb = NULLP;
2038    RLC_BearerConfig_t *rlcCfg = NULLP;
2039    RLC_Config_t *rlcLcCfg = NULLP;
2040    LogicalChannelConfig_t *macLcCfg = NULLP;
2041 #ifdef NR_DRX
2042    DrxCfg    drxCfg;
2043 #endif
2044
2045    if(ueCb == NULLP)
2046    {
2047       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
2048       return RFAILED;
2049    }
2050
2051    if(cellGrpCfg == NULLP)
2052    {
2053       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
2054       return RFAILED;
2055    }
2056
2057 #ifdef NR_DRX
2058    if(cellGrpCfg->mac_CellGroupConfig)
2059    {
2060       if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc)
2061       {
2062          switch(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->present)
2063          {
2064             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
2065                break;
2066
2067             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
2068             {
2069                if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup)
2070                {
2071                   ueCb->drxCfgPresent = true;
2072                   storeDrxCfgInUeCb(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup, &ueCb->drxCfg);
2073                }
2074                break;
2075             }
2076
2077             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
2078                break;
2079          }
2080       }
2081    }
2082 #endif
2083
2084    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
2085    {
2086       srbFound = false;
2087       drbFound = false;
2088
2089       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
2090
2091       /* Update SRB configuration in local DB */
2092       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
2093       {
2094          /* Search if SRB entry is already present in DB */
2095          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
2096          {
2097             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
2098             {
2099               srbCfgDb = &ueCb->srbList[srbIdx];
2100               srbFound = true;
2101               break;
2102             }
2103          }
2104
2105          /* If not, add SRB to UE CB's SRB list */
2106          if(!srbFound)
2107          {
2108             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
2109             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
2110             ueCb->numSrb++;
2111          }
2112
2113          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2114          srbCfgDb->cfgSentToUe = false;
2115          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
2116          macLcCfgDb = &srbCfgDb->macLcCfg;
2117       }
2118
2119       /* Update DRB configuration in local DB */
2120       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
2121       {
2122          /* Search if DRB entry is already present in DB */
2123          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
2124          {
2125             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
2126             {
2127               drbCfgDb = &ueCb->drbList[drbIdx];
2128               drbFound = true;
2129               break;
2130             }
2131          }
2132
2133          /* If not, add DRB to UE CB's SRB list */
2134          if(!drbFound)
2135          {
2136             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
2137             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
2138             ueCb->numDrb++;
2139          }
2140
2141          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2142          drbCfgDb->cfgSentToUe = false;
2143          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
2144          macLcCfgDb = &drbCfgDb->macLcCfg;
2145       }
2146
2147
2148       /* Update RLC configuration for this RB */
2149       rlcLcCfg = rlcCfg->rlc_Config;
2150       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
2151       switch(rlcLcCfgDb->rlcMode)
2152       {
2153          case RLC_Config_PR_am:
2154             {
2155                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
2156                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
2157                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
2158                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
2159                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
2160
2161                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
2162                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
2163                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
2164                break;
2165             }
2166
2167          case RLC_Config_PR_um_Bi_Directional:
2168             {
2169                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
2170
2171                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
2172                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
2173                break;
2174             }
2175       }
2176
2177       /* Update MAC configuration for this LC */
2178       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
2179       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
2180       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
2181       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
2182       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
2183       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
2184    }
2185    return ROK;
2186 }
2187
2188 /*******************************************************************
2189  *
2190  * @brief Function to decode DU to CU RRC container
2191  *
2192  * @details
2193  *
2194  *    Function : extractDuToCuRrcCont
2195  *
2196  *    Functionality: Function to decode DU to CU RRC container
2197  *
2198  * @params[in] UE Cb
2199  *             RRC conatiner octect string to be decoded
2200  *
2201  * @return ROK     - success
2202  *         RFAILED - failure
2203  *
2204  * ****************************************************************/
2205 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
2206 {
2207    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
2208    asn_dec_rval_t rval; /* Decoder return value */
2209
2210    /* Copy the received container to UeCb */
2211    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
2212
2213    /* Decoding DU to CU RRC container octet string to cell group config */
2214    cellGrpCfgMsg = &cellGrpCfg;
2215    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
2216
2217    rval = uper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
2218
2219    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2220    {
2221       DU_LOG("\nERROR  -->  F1AP : ASN decode failed in extractDuToCuRrcCont");
2222       return RFAILED;
2223    }
2224    printf("\n");
2225    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
2226
2227    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
2228    {
2229       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
2230       return RFAILED;
2231    }
2232
2233    return ROK;
2234 }
2235
2236 /*******************************************************************
2237  *
2238  * @brief Function to build Initial UL RRC Message
2239  *
2240  * @details
2241  *
2242  *    Function : procInitULRRCMsg
2243  *
2244  *    Functionality: Function to build Initial UL RRC Message
2245  *
2246  * @params[in]
2247  *
2248  * @return ROK     - success
2249  *         RFAILED - failure
2250  *
2251  * ****************************************************************/
2252
2253 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2254 {
2255    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2256    uint8_t ret =ROK;
2257    uint16_t cellIdx=0, nrCellId = 0;
2258    uint32_t crnti;
2259    DuDb     *duDb;
2260    CuCellCb *cellCb;
2261    CuUeCb   *ueCb;
2262    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2263
2264    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2265
2266    SEARCH_DU_DB(duIdx, duId, duDb);
2267    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2268
2269    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2270    {
2271       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2272       {
2273          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2274             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2275             break;
2276
2277          case ProtocolIE_ID_id_NRCGI:
2278             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2279             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2280             if(cellCb == NULLP)
2281                return RFAILED;
2282             break;
2283
2284          case ProtocolIE_ID_id_C_RNTI:
2285             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2286             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2287             {
2288                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2289                memset(ueCb, 0, sizeof(CuUeCb));
2290                ueCb->cellCb = cellCb;
2291                ueCb->crnti = crnti;
2292                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2293                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2294                ueCb->state = UE_ATTACH_IN_PROGRESS;
2295                (duDb->numUe)++;
2296
2297                cellCb->ueCb[cellCb->numUe] = ueCb;
2298                cellCb->numUe++;
2299             }
2300             break;
2301
2302          case ProtocolIE_ID_id_RRCContainer:
2303             break;
2304
2305          case ProtocolIE_ID_id_DUtoCURRCContainer:
2306             {
2307                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2308                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2309                {
2310                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2311                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2312                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2313                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2314                   {
2315                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2316                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2317                         ueCb->f1apMsgDb.duToCuContainer.size);
2318                   }
2319                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2320                   {
2321                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2322                      ret = RFAILED;
2323                   }
2324                }
2325                else
2326                {
2327                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2328                   ret = RFAILED;
2329                }
2330                break;
2331             }
2332
2333          default:
2334             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2335             break;
2336       }
2337       if(ret == RFAILED)
2338          break;
2339    }
2340
2341    if(ret == ROK)
2342    {
2343       ueCb->f1apMsgDb.dlRrcMsgCount++;
2344       rrcMsgType = setDlRRCMsgType(ueCb);
2345       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2346    }
2347    return ret;
2348 }
2349
2350 /*******************************************************************
2351  *
2352  * @brief Builds Nrcgi
2353  *
2354  * @details
2355  *
2356  *    Function : BuildNrcgi
2357  *
2358  *    Functionality: Building the PLMN ID and NR Cell id
2359  *
2360  * @params[in] NRCGI_t *nrcgi
2361  * @return ROK     - success
2362  *         RFAILED - failure
2363  *
2364  * ****************************************************************/
2365 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2366 {
2367    uint8_t ret;
2368    uint8_t unused_bits = 4;
2369    uint8_t byteSize = 5;
2370
2371    /* Allocate Buffer Memory */
2372    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2373    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2374    if(nrcgi->pLMN_Identity.buf == NULLP)
2375    {
2376       return RFAILED;
2377    }
2378    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2379
2380    if(ret != ROK)
2381    {
2382       return RFAILED;
2383    }
2384    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2385    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2386    if(nrcgi->nRCellIdentity.buf == NULLP)
2387    {
2388       return RFAILED;
2389    }
2390    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2391
2392    return ROK;
2393 }
2394 /*******************************************************************
2395  *
2396  * @brief Builds Special cell list for UE Setup Request
2397  *
2398  * @details
2399  *
2400  *    Function : BuildSplCellList
2401  *
2402  *    Functionality: Constructs the Special Cell list for UESetReq
2403  *
2404  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2405  *
2406  * @return ROK     - success
2407  *         RFAILED - failure
2408  *
2409  * ****************************************************************/
2410 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2411 {
2412    uint8_t  cellCnt;
2413    uint8_t  idx;
2414    uint8_t  ret;
2415    cellCnt = 1;
2416    spCellLst->list.count = cellCnt;
2417    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2418    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2419    if(spCellLst->list.array == NULLP)
2420    {
2421       return RFAILED;
2422    }
2423    for(idx=0; idx<cellCnt; idx++)
2424    {
2425       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2426       if(spCellLst->list.array[idx] == NULLP)
2427       {
2428          return RFAILED;
2429       }
2430    }
2431    idx = 0;
2432    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2433    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2434    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2435
2436    /* Special Cell ID -NRCGI */
2437    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2438    if(ret != ROK)
2439    {
2440       return RFAILED;
2441    }
2442    /*Special Cell Index*/
2443    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2444    return ROK;
2445 }/* End of BuildSplCellList*/
2446
2447 /*******************************************************************
2448  *
2449  * @brief Builds SRBS to be setup
2450  *
2451  * @details
2452  *
2453  *    Function : BuildSRBSetup
2454  *
2455  *    Functionality: Constructs the SRB's for UESetReq
2456  *
2457  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2458  *
2459  * @return ROK     - success
2460  *         RFAILED - failure
2461  *
2462  * ****************************************************************/
2463 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2464 {
2465    uint8_t idx;
2466    uint8_t srbCnt;
2467
2468    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2469       srbCnt = ueCb->numSrb;
2470    else
2471       srbCnt = 1;
2472    srbSet->list.count = srbCnt;
2473    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2474    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2475    if(srbSet->list.array == NULLP)
2476    {
2477       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2478       return RFAILED;
2479    }
2480
2481    for(idx=0; idx<srbCnt; idx++)
2482    {
2483       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2484       if(srbSet->list.array[idx] == NULLP)
2485       {
2486          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2487          return RFAILED;
2488       }
2489    }
2490
2491    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2492    {
2493       idx = 0;
2494       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2495       srbSet->list.array[idx]->criticality = Criticality_ignore;
2496       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2497       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2498       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2499       ueCb->numSrb++;
2500    }
2501    else
2502    {
2503       for(idx=0; idx<srbCnt; idx++)
2504       {
2505          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2506          srbSet->list.array[idx]->criticality = Criticality_ignore;
2507          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2508          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2509       }
2510    }
2511    return ROK;
2512 }/* End of BuildSRBSetup*/
2513
2514 /*******************************************************************
2515  *
2516  * @brief Builds QOS Info for DRB Setum Item
2517  *
2518  * @details
2519  *
2520  *    Function : BuildQOSInfo
2521  *
2522  *    Functionality: Constructs the QOS Info for DRB Setup Item
2523  *
2524  * @params[in] QoSInformation_t *qosinfo
2525  *             int16_t pduSessionID
2526  *
2527  * @return ROK     - success
2528  *         RFAILED - failure
2529  *
2530  * ****************************************************************/
2531 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2532 {
2533    uint8_t elementCnt = 0, qosCntIdx = 0;
2534    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2535
2536    /* NonDynamic5QIDescriptor */
2537    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2538    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2539    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2540    {
2541       return RFAILED;
2542    }
2543
2544    if(hoInProgress)
2545       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2546    else
2547    {
2548       /*FiveQI*/
2549       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2550          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2551       else
2552          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2553
2554       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2555    }
2556
2557    if(!hoInProgress)
2558    {
2559       /*AveragingWindow*/
2560       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2561       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2562       {
2563          return RFAILED;
2564       }
2565       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2566       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2567
2568       /*MaxDataBurstVolume*/
2569       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2570       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2571       {
2572          return RFAILED;
2573       }
2574       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2575       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2576    }
2577
2578    /*nRGRAN Allocation Retention Priority*/
2579    if(hoInProgress)
2580    {
2581       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2582       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2583       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2584    }
2585    else
2586    {
2587       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2588       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2589       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2590
2591       qosInfo->priorityLevel = PriorityLevel_lowest;
2592       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2593       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2594    }
2595
2596    /* PDU session ID */
2597    if(!hoInProgress)
2598    {
2599       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2600       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2601       {
2602          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2603          return ROK;
2604       }
2605
2606       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2607       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2608
2609       if(qosIeExt)
2610       {
2611          elementCnt = NUM_QOS_EXT;
2612          qosIeExt->list.count = elementCnt;
2613          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2614
2615          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2616          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2617
2618          if(qosIeExt->list.array == NULLP)
2619          {
2620             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2621             return  RFAILED;
2622          }
2623
2624          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2625          {
2626             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2627             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2628             {
2629                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2630                return  RFAILED;
2631             }
2632             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2633             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2634             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2635             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2636             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2637                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2638             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2639             qosInfo->pduSessionId = pduSessionID;
2640          }
2641       }
2642       else
2643       {
2644          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2645          return RFAILED;
2646       }
2647    }
2648    return ROK;
2649 }/*End of BuildQOSInfo*/
2650
2651 /*******************************************************************
2652  *
2653  * @brief Builds SNSSAI
2654  *
2655  * @details
2656  *
2657  *    Function : BuildSNSSAI
2658  *
2659  *    Functionality: Constructs the SNSSAI For DRB list
2660  *
2661  * @params[in] SNSSAI_t *snssai
2662  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2663  *
2664  * @return ROK     - success
2665  *         RFAILED - failure
2666  *
2667  * ****************************************************************/
2668 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2669 {
2670    /*SNSSAI*/
2671    /*ssT*/
2672    snssai->sST.size = sizeof(uint8_t);
2673    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2674    if(snssai->sST.buf == NULLP)
2675    {
2676       return RFAILED;
2677    }
2678    if(!hoInProgress)
2679       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2680    else
2681       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2682
2683    /*sD*/
2684    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2685    if(snssai->sD == NULLP)
2686    {
2687       return RFAILED;
2688    }
2689    snssai->sD->size = 3 * sizeof(uint8_t);
2690    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2691    if(snssai->sD->buf == NULLP)
2692    {
2693       return RFAILED;
2694    }
2695    if(!hoInProgress)
2696       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2697    else
2698       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2699
2700    if(!hoInProgress)
2701       drbInfo->snssai = snssaiToCopy;
2702    return ROK;
2703 }/*End of BuildSNSSAI*/
2704
2705 /*******************************************************************
2706  *
2707  * @brief Builds the flow map.
2708  *
2709  * @details
2710  *
2711  *    Function : BuildFlowsMap
2712  *
2713  *    Functionality: Constructs the flowmap For DRB list
2714  *
2715  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2716  *
2717  * @return ROK     - success
2718  *         RFAILED - failure
2719  *
2720  * ****************************************************************/
2721 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2722 {
2723    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2724    FlowsMapped *qosFlow;
2725
2726    if(!hoInProgress)
2727       flowCnt = 1;
2728    else
2729       flowCnt = drbInfo->numFlowMap;
2730    flowMap->list.count = flowCnt;
2731    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2732    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2733    if(flowMap->list.array == NULLP)
2734    {
2735       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2736       return RFAILED;
2737    }
2738    for(idx=0; idx<flowCnt; idx++)
2739    {
2740       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2741       if(flowMap->list.array[idx] == NULLP)
2742       {
2743          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2744          return RFAILED;
2745       }
2746
2747       if(!hoInProgress)
2748       {
2749          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2750          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2751          {
2752             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2753             {
2754                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2755                {
2756                   qosFlow = &drbInfo->flowMapList[flowIdx];
2757                   break;
2758                }
2759             }
2760          }
2761          else
2762          {
2763             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2764             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2765          }
2766       }
2767       else
2768       {
2769          qosFlow = &drbInfo->flowMapList[idx];
2770          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2771       }
2772
2773       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2774             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2775       if(ret != ROK)
2776       {
2777          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2778          return RFAILED;
2779       }
2780
2781       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2782          drbInfo->numFlowMap++;
2783    }
2784    return ROK;
2785 }/*End of BuildFlowsMap*/
2786
2787 /*******************************************************************
2788  *
2789  * @brief Builds the Uplink Tunnel Info
2790  *
2791  * @details
2792  *
2793  *    Function : BuildULTnlInfo
2794  *
2795  *    Functionality: Constructs the UL TnlInfo For DRB list
2796  *
2797  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2798  *
2799  * @return ROK     - success
2800  *         RFAILED - failure
2801  *
2802  * ****************************************************************/
2803 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2804 {
2805    uint8_t idx;
2806    uint8_t ulCnt;
2807
2808    ulCnt = 1;
2809    ulInfo->list.count = ulCnt;
2810    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2811    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2812    if(ulInfo->list.array == NULLP)
2813    {
2814       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2815       return RFAILED;
2816    }
2817    for(idx=0; idx<ulCnt; idx++)
2818    {
2819       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2820       if(ulInfo->list.array[idx] == NULLP)
2821       {
2822          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2823               return RFAILED;
2824       }
2825    }
2826    idx = 0;
2827    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2828    /*GTP TUNNEL*/
2829    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2830    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2831    {
2832       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2833       return RFAILED;
2834    }
2835    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2836    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2837       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2838    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2839    {
2840       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2841       return RFAILED;
2842    }
2843
2844    if(!hoInProgress)
2845    {
2846       /* NOTE: Below IP address must be changed if running on different IP configuration */
2847       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2848       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2849       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2850       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2851       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2852
2853       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2854       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2855       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2856       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2857    }
2858    else
2859    {
2860       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2861       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2862       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2863       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2864       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2865    }
2866
2867    /*GTP TEID*/
2868    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2869    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2870       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2871    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2872    {
2873       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2874       return RFAILED;
2875    }
2876
2877    if(!hoInProgress)
2878    {
2879       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2880       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2881       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2882       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2883
2884       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2885       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2886       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2887       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2888    }
2889    else
2890    {
2891       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2892       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2893       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2894       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2895    }
2896    return ROK;
2897 }/*End of BuildULTnlInfo*/
2898
2899 /*******************************************************************
2900  *
2901  * @brief Builds DRBS to be setup
2902  *
2903  * @details
2904  *
2905  *    Function : BuildDRBSetup
2906  *
2907  *    Functionality: Constructs the DRB's for UESetReq
2908  *
2909  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2910  *
2911  * @return ROK     - success
2912  *         RFAILED - failure
2913  *
2914  * ****************************************************************/
2915 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2916 {
2917    uint16_t snssaiIdx=0;
2918    uint8_t idx = 0, extIeIdx = 0;
2919    uint8_t elementCnt = 0, drbCnt = 0;
2920    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2921    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2922    DRBs_ToBeSetup_Item_t *drbSetItem;
2923    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2924    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2925
2926    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2927       drbCnt = ueCb->numDrb;
2928    else
2929       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2930    drbSet->list.count = drbCnt;
2931
2932    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2933    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2934    if(drbSet->list.array == NULLP)
2935    {
2936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2937       return RFAILED;
2938    }
2939
2940    for(idx=0; idx<drbCnt; idx++)
2941    {
2942       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2943       if(drbSet->list.array[idx] == NULLP)
2944       {
2945          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2946          return RFAILED;
2947       }
2948
2949       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2950       drbSet->list.array[idx]->criticality = Criticality_ignore;
2951       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2952       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2953       /*dRBID*/
2954       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2955       {
2956          drbSetItem->dRBID = idx + 1;
2957          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2958       }
2959       else
2960          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2961
2962       /*qoSInformation*/
2963       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2964       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2965       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2966       {
2967          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2968          return RFAILED;
2969       }
2970       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2971       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2972       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2973       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2974          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2975                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2976       else
2977          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2978                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2979       if(BuildQOSInforet != ROK)
2980       {
2981          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2982          return RFAILED;
2983       }
2984
2985       /*SNSSAI*/
2986       snssaiIdx = (idx% cuCb.numSnssaiSupported);
2987       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2988          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2989                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
2990       else
2991          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2992                choice_extension->value.choice.DRB_Information.sNSSAI, NULLP, TRUE);
2993       if(BuildSNSSAIret != ROK)
2994       {
2995          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2996          return RFAILED;
2997       }
2998
2999       /*Flows mapped to DRB List*/
3000       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3001          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
3002                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
3003       else
3004          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
3005                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
3006       if(BuildFlowsMapret != ROK)
3007       {
3008          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
3009          return RFAILED;
3010       }
3011
3012       /*ULUPTNLInformation To Be Setup List*/
3013       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3014          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3015                FALSE);
3016       else
3017          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
3018                TRUE);
3019       if(BuildULTnlInforet != ROK)
3020       {
3021          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
3022          return RFAILED;
3023       }
3024
3025       /*RLCMode*/
3026       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3027       {
3028          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
3029          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
3030       }
3031       else
3032          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
3033
3034       /* DL PDCP SN Length */
3035       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
3036       {
3037          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
3038          if(!drbToBeSetupExt)
3039          {
3040             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
3041             return RFAILED;
3042          }
3043
3044          elementCnt = 1;
3045          drbToBeSetupExt->list.count = elementCnt;
3046          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
3047
3048          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
3049          if(!drbToBeSetupExt->list.array)
3050          {
3051              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
3052              return RFAILED;
3053          }
3054
3055          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
3056          {
3057             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
3058             if(!drbToBeSetupExt->list.array[extIeIdx])
3059             {
3060                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
3061                return RFAILED;
3062             }
3063          }
3064
3065          extIeIdx = 0;
3066          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
3067
3068          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
3069          drbToBeSetupExtIe->criticality = Criticality_ignore;
3070          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
3071          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
3072          drbSetItem->iE_Extensions = drbToBeSetupExt;
3073       }
3074
3075       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3076          ueCb->numDrb++;
3077    }
3078    return ROK;
3079 }/* End of BuildDRBSetup*/
3080
3081 /*******************************************************************
3082  *
3083  * @brief Deallocating memory of function BuildAndSendUESetReq
3084  *
3085  * @details
3086  *
3087  *    Function : FreeNrcgi
3088  *
3089  *    Functionality: Deallocating memory for function BuildNrcgi
3090  *
3091  * @params[in] NRCGI_t *nrcgi
3092  *
3093  * @return void
3094  *
3095  *******************************************************************/
3096 void FreeNrcgi(NRCGI_t *nrcgi)
3097 {
3098    if(nrcgi->pLMN_Identity.buf != NULLP)
3099    {
3100       if(nrcgi->nRCellIdentity.buf != NULLP)
3101       {
3102          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
3103       }
3104       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
3105    }
3106 }
3107 /*******************************************************************
3108  *
3109  * @brief  Deallocating memory of function BuildAndSendUESetReq
3110  *
3111  * @details
3112  *
3113  *    Function : FreeSplCellList
3114  *
3115  *    Functionality: Deallocating memory for function BuildSplCellList
3116  *
3117  * @params[in] SCell_ToBeSetup_List_t *spCellLst
3118  *
3119  * @return void
3120  *
3121  *
3122  * *****************************************************************/
3123 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
3124 {
3125    uint8_t  cellidx;
3126    if(spCellLst->list.array != NULLP)
3127    {
3128       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
3129       {
3130          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
3131          {
3132             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
3133          }
3134          if(spCellLst->list.array[cellidx]!=NULLP)
3135          {
3136             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
3137          }
3138       }
3139       CU_FREE(spCellLst->list.array,spCellLst->list.size);
3140    }
3141 }
3142 /*******************************************************************
3143  *
3144  * @brief Deallocating memory of function BuildAndSendUESetReq
3145  *
3146  * @details
3147  *
3148  *    Function : FreeSRBSetup
3149  *
3150  *    Functionality: Deallocating memory for function BuildSRBSetup
3151  *
3152  * @params[in] SRBs_ToBeSetup_List_t *srbSet
3153  *
3154  * @return void
3155  *
3156  *
3157  * ******************************************************************/
3158 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
3159 {
3160    uint8_t srbidx;
3161    if(srbSet->list.array != NULLP)
3162    {
3163       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
3164       {
3165          if(srbSet->list.array[srbidx]!=NULLP)
3166          {
3167             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
3168          }
3169       }
3170       CU_FREE(srbSet->list.array,srbSet->list.size);
3171    }
3172 }
3173 /*******************************************************************
3174  *
3175  * @brief Deallocating memory of function BuildAndSendUESetReq
3176  *
3177  * @details
3178  *
3179  *    Function : FreeQOSInfo
3180  *
3181  *    Functionality:  Deallocating memory for function BuildQOSInfo
3182  *
3183  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
3184  *
3185  * @return void
3186  *
3187  * ****************************************************************/
3188 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
3189 {
3190    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3191    uint8_t qosCntIdx = 0;
3192
3193    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
3194    {
3195       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3196       {
3197          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3198          {
3199             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3200                   sizeof(MaxDataBurstVolume_t));
3201          }
3202          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3203                sizeof(AveragingWindow_t));
3204       }
3205       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3206             sizeof(NonDynamic5QIDescriptor_t));
3207    }
3208    if(drbQos->iE_Extensions)
3209    {
3210       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
3211       if(qosIeExt->list.array != NULLP)
3212       {
3213          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
3214          {
3215             if(qosIeExt->list.array[qosCntIdx])
3216             {
3217                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3218             }
3219          }
3220          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3221       }
3222
3223       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3224    }
3225 }
3226 /*******************************************************************
3227  *
3228  * @brief Deallocating memory of function BuildAndSendUESetReq
3229  *
3230  * @details
3231  *
3232  *    Function : FreeULTnlInfo
3233  *
3234  *    Functionality:  Deallocating memory for function BuildULTnlInfo
3235  *
3236  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
3237  *
3238  * @return void
3239  *
3240
3241  * ****************************************************************/
3242 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
3243 {
3244    uint8_t ulidx=0;
3245    if(ulInfo->list.array != NULLP)
3246    {
3247       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
3248       {
3249          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3250          {
3251             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3252             {
3253                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3254                      transportLayerAddress.buf != NULLP)
3255                {
3256                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3257                         !=NULLP)
3258                   {
3259                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3260                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3261                            gTPTunnel->gTP_TEID.size);
3262                   }
3263                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3264                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3265                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3266                }
3267                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3268                      sizeof(GTPTunnel_t));
3269             }
3270          }
3271          if(ulInfo->list.array[ulidx]!=NULLP)
3272          {
3273             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3274          }
3275       }
3276       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3277    }
3278 }
3279 /*******************************************************************
3280  *
3281  * @brief Deallocating memory for BuildAndSendUESetReq
3282  *
3283  * @details
3284  *
3285  *    Function : FreeDRBSetup
3286  *
3287  *    Functionality:  Deallocating memory for BuildDRBSetup
3288  *
3289  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3290  *
3291  * @return void
3292  *
3293  * ****************************************************************/
3294 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3295 {
3296    DRBs_ToBeSetup_Item_t *drbSetItem;
3297    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3298
3299    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3300
3301    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3302    if(drbSet->list.array != NULLP)
3303    {
3304       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3305       {
3306               if(drbSet->list.array[drbidx] != NULLP)
3307               {
3308                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3309                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3310                  {
3311                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3312                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3313                {
3314                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3315                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3316                             {
3317                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3318                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3319                                {
3320                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3321                                        {
3322                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3323                                           {
3324                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3325                                              {
3326                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3327                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3328                                                      {
3329                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3330                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3331                                                          {
3332                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3333                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3334                                                              {
3335                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3336                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3337                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3338                                                                      {
3339                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3340                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3341                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3342                                                                          {
3343                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3344                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3345                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3346                                                                                   {
3347                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3348                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3349
3350                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3351                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3352                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3353                                                                                                    sizeof(MaxDataBurstVolume_t));
3354                                                                                   }
3355                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3356                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3357                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3358                                                                          }
3359                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3360                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3361                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3362                                                                      }
3363                                                             }
3364                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3365                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3366                                                             {
3367                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3368                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3369                                                             }
3370                                                         }
3371                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3372                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3373                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3374                                                      }
3375                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3376                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3377                                             }
3378                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3379                                                               sizeof(OCTET_STRING_t));
3380                                        }
3381                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3382                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3383                                     }
3384                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3385                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3386                             }
3387                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3388                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3389                          }
3390                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3391                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3392              }
3393              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3394                         iE_Extensions != NULLP)
3395              {
3396                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3397                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3398                  if(qosIeExt->list.array != NULLP)
3399                  {
3400                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3401                    {
3402                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3403                       {
3404                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3405                       }
3406                     }
3407                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3408                   }
3409                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3410                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3411               }
3412
3413                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3414                 }
3415                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3416               }
3417       }
3418       CU_FREE(drbSet->list.array,drbSet->list.size);
3419    }
3420 }
3421
3422
3423 /*******************************************************************
3424  *
3425  * @brief Free the UE Setup Request
3426  *
3427  * @details
3428  *
3429  *    Function : FreeUeContextSetupReq
3430  *
3431  *    Functionality: Deallocate the memory of BuildUESetReq
3432  *
3433  * @params[in]  F1AP_PDU_t  *f1apMsg
3434  *
3435  * @return void
3436  *
3437  *
3438  * ****************************************************************/
3439 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3440 {
3441    uint8_t idx, ieId;
3442    UEContextSetupRequest_t  *ueSetReq = NULLP;
3443
3444    if(f1apMsg != NULLP)
3445    {
3446       if(f1apMsg->choice.initiatingMessage != NULLP)
3447       {
3448          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3449          if(ueSetReq->protocolIEs.list.array != NULLP)
3450          {
3451             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3452             {
3453                if(ueSetReq->protocolIEs.list.array[idx])
3454                {
3455                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3456                   {
3457                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3458                         break;
3459                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3460                         break;
3461                      case ProtocolIE_ID_id_SpCell_ID:
3462                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3463                         break;
3464                      case ProtocolIE_ID_id_ServCellIndex:
3465                         break;
3466                      case ProtocolIE_ID_id_SpCellULConfigured:
3467                         break;
3468                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3469                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3470                         break;
3471                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3472                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3473                         break;
3474                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3475                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3476                         break;
3477                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3478                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3479                         break;
3480                      case ProtocolIE_ID_id_RRCContainer:
3481                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3482                         {
3483                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3484                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3485                         }
3486                         break;
3487                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3488                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3489                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3490                         break;
3491                      default:
3492                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3493                         break;
3494                   }
3495                }
3496                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3497             }
3498             for(ieId=0; ieId<idx; ieId++)
3499             {
3500                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3501                {
3502                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3503                }
3504             }
3505             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3506          }
3507          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3508       }
3509       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3510    }
3511 }
3512
3513 /**Filling cell group info **/
3514 /*******************************************************************
3515  *
3516  * @brief Build Control resource set to add/modify list
3517  *
3518  * @details
3519  *
3520  *    Function : BuildControlRSetToAddModList
3521  *
3522  *    Functionality: Build Control resource set to add/modify list
3523  *
3524  * @params[in]
3525  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3526  *
3527  * @return ROK     - success
3528  *         RFAILED - failure
3529  *
3530  * ****************************************************************/
3531    uint8_t BuildControlRSetToAddModList
3532 (
3533  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3534  )
3535 {
3536    uint8_t idx;
3537    uint8_t elementCnt;
3538    uint8_t numBytes, bitsUnused;
3539    struct ControlResourceSet *controlRSet;
3540    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3541    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3542
3543    elementCnt = 1;
3544    controlRSetList->list.count = elementCnt;
3545    controlRSetList->list.size = \
3546                                 elementCnt * sizeof(struct ControlResourceSet *);
3547
3548    controlRSetList->list.array = NULLP;
3549    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3550    if(!controlRSetList->list.array)
3551    {
3552       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3553       return RFAILED;
3554    }
3555
3556    for(idx = 0; idx < elementCnt; idx++)
3557    {
3558       controlRSetList->list.array[idx] = NULLP;
3559       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3560       if(!controlRSetList->list.array[idx])
3561       {
3562          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3563          return RFAILED;
3564       }
3565    }
3566
3567    idx=0;
3568    controlRSet = controlRSetList->list.array[idx];
3569    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3570
3571    /* Values harcoded according to our design:
3572     * size 6 bytes
3573     * 3 LSBs unsued
3574     * Bit string stored ff0000000000
3575     */
3576    numBytes = 6;
3577    bitsUnused = 3;
3578    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3579    controlRSet->frequencyDomainResources.buf = NULLP;
3580    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3581          controlRSet->frequencyDomainResources.size);
3582    if(!controlRSet->frequencyDomainResources.buf)
3583    {
3584       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3585       return RFAILED;
3586    }
3587
3588    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3589    coreset0EndPrb = CORESET0_END_PRB;
3590    coreset1StartPrb = coreset0EndPrb + 6;
3591    coreset1NumPrb = CORESET1_NUM_PRB;
3592    /* calculate the PRBs */
3593    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3594    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3595    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3596
3597    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3598    controlRSet->cce_REG_MappingType.present = \
3599                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3600
3601    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3602    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3603    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3604    controlRSet->tci_PresentInDCI = NULLP;
3605 #if 0
3606    uint8_t tciStateIdx;
3607
3608    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3609          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3610    if(!controlRset->tci_StatesPDCCH_ToAddList)
3611    {
3612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3613       return RFAILED;
3614    }
3615
3616    elementCnt = 1;
3617    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3618    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3619    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3620          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3621       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3622       {
3623          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3624          return RFAILED;
3625       }
3626
3627    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3628    {
3629       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3630       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3631       {
3632          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3633          return RFAILED;
3634       }
3635    }
3636
3637    tciStateIdx = 0;
3638    /* TODO */
3639    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3640
3641    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3642    if(!controlRset->tci_PresentInDCI)
3643    {
3644       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3645       return RFAILED;
3646    }
3647    /* TODO */
3648    *(controlRset->tci_PresentInDCI);
3649 #endif
3650
3651    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3652    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3653    if(!controlRSet->pdcch_DMRS_ScramblingID)
3654    {
3655       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3656       return RFAILED;
3657    }
3658    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3659
3660    return ROK;
3661 } /* End BuildControlRSetToAddModList */
3662
3663 /*******************************************************************
3664  *
3665  * @brief Build search space to add/modify list
3666  *
3667  * @details
3668  *
3669  *    Function : BuildSearchSpcToAddModList
3670  *
3671  *    Functionality: Build search space to add/modify list
3672  *
3673  * @params[in]
3674  * @return ROK     - success
3675  *         RFAILED - failure
3676  *
3677  * ****************************************************************/
3678    uint8_t BuildSearchSpcToAddModList
3679 (
3680  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3681  )
3682 {
3683    uint8_t idx;
3684    uint8_t numBytes;
3685    uint8_t byteIdx;
3686    uint8_t bitsUnused;
3687    uint8_t elementCnt;
3688    struct SearchSpace *searchSpc;
3689
3690    elementCnt = 1;
3691    searchSpcList->list.count = elementCnt;
3692    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3693
3694    searchSpcList->list.array = NULLP;
3695    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3696    if(!searchSpcList->list.array)
3697    {
3698       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3699       return RFAILED;
3700    }
3701
3702    for(idx = 0; idx < elementCnt; idx++)
3703    {
3704       searchSpcList->list.array[idx] = NULLP;
3705       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3706       if(!searchSpcList->list.array[idx])
3707       {
3708          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3709          return RFAILED;
3710       }
3711    }
3712
3713    idx = 0;
3714    searchSpc = searchSpcList->list.array[idx];
3715
3716    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3717
3718    searchSpc->controlResourceSetId = NULLP;
3719    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3720    if(!searchSpc->controlResourceSetId)
3721    {
3722       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3723       return RFAILED;
3724    }
3725    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3726
3727    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3728    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3729          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3730    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3731    {
3732       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3733       return RFAILED;
3734    }
3735    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3736                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3737
3738    searchSpc->duration = NULLP;
3739    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3740    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3741    if(!searchSpc->monitoringSymbolsWithinSlot)
3742    {
3743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3744       return RFAILED;
3745    }
3746
3747    /* Values taken from reference logs :
3748     * size 2 bytes
3749     * 2 LSBs unsued
3750     * Bit string stores 8000
3751     */
3752    numBytes = 2;
3753    bitsUnused = 2;
3754
3755    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3756    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3757    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3758          searchSpc->monitoringSymbolsWithinSlot->size);
3759    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3760    {
3761       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3762       return RFAILED;
3763    }
3764
3765    byteIdx = 0;
3766    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3767                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3768    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3769    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3770
3771    searchSpc->nrofCandidates = NULLP;
3772    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3773    if(!searchSpc->nrofCandidates)
3774    {
3775       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3776       return RFAILED;
3777    }
3778
3779    searchSpc->nrofCandidates->aggregationLevel1 = \
3780                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3781    searchSpc->nrofCandidates->aggregationLevel2 = \
3782                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3783    searchSpc->nrofCandidates->aggregationLevel4 = \
3784                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3785    searchSpc->nrofCandidates->aggregationLevel8 = \
3786                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3787    searchSpc->nrofCandidates->aggregationLevel16 = \
3788                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3789
3790    searchSpc->searchSpaceType = NULLP;
3791    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3792    if(!searchSpc->searchSpaceType)
3793    {
3794       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3795       return RFAILED;
3796    }
3797
3798    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3799
3800    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3801    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3802          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3803    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3804    {
3805       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3806       return RFAILED;
3807    }
3808    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3809                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3810
3811    return ROK;
3812 }/* End BuildSearchSpcToAddModList */
3813
3814 /*******************************************************************
3815  *
3816  * @brief Builds BWP DL dedicated PDCCH config
3817  *
3818  * @details
3819  *
3820  *    Function : BuildBWPDlDedPdcchCfg
3821  *
3822  *    Functionality: Builds BWP DL dedicated PDCCH config
3823  *
3824  * @params[in] struct PDCCH_Config *pdcchCfg
3825  *
3826  * @return ROK     - success
3827  *         RFAILED - failure
3828  *
3829  * ****************************************************************/
3830 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3831 {
3832    pdcchCfg->controlResourceSetToAddModList = NULLP;
3833    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3834          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3835    if(!pdcchCfg->controlResourceSetToAddModList)
3836    {
3837       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3838       return RFAILED;
3839    }
3840
3841    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3842    {
3843       return RFAILED;
3844    }
3845
3846    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3847
3848    pdcchCfg->searchSpacesToAddModList = NULLP;
3849    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3850          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3851    if(!pdcchCfg->searchSpacesToAddModList)
3852    {
3853       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3854       return RFAILED;
3855    }
3856
3857    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3858    {
3859       return RFAILED;
3860    }
3861
3862    pdcchCfg->searchSpacesToReleaseList = NULLP;
3863    pdcchCfg->downlinkPreemption = NULLP;
3864    pdcchCfg->tpc_PUSCH = NULLP;
3865    pdcchCfg->tpc_PUCCH = NULLP;
3866    pdcchCfg->tpc_SRS = NULLP;
3867
3868    return ROK;
3869 }
3870
3871 /*******************************************************************
3872  *
3873  * @brief Builds DMRS DL PDSCH Mapping type A
3874  *
3875  * @details
3876  *
3877  *    Function : BuildDMRSDLPdschMapTypeA
3878  *
3879  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3880  *
3881  * @params[in]
3882  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3883  * @return ROK     - success
3884  *         RFAILED - failure
3885  *
3886  * ****************************************************************/
3887    uint8_t BuildDMRSDLPdschMapTypeA
3888 (
3889  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3890  )
3891 {
3892    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3893    dmrsDlCfg->choice.setup = NULLP;
3894    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3895    if(!dmrsDlCfg->choice.setup)
3896    {
3897       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3898       return RFAILED;
3899    }
3900
3901    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3902    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3903    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3904    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3905    {
3906       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3907       return RFAILED;
3908    }
3909    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3910
3911    dmrsDlCfg->choice.setup->maxLength = NULLP;
3912    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3913    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3914    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3915
3916    return ROK;
3917 }
3918
3919 /*******************************************************************
3920  *
3921  * @brief Builds TCI states to add/modify list
3922  *
3923  * @details
3924  *
3925  *    Function : BuildTCIStatesToAddModList
3926  *
3927  *    Functionality:Builds TCI states to add/modify list
3928  *
3929  * @params[in]
3930  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3931  *
3932  * @return ROK     - success
3933  *         RFAILED - failure
3934  *
3935  * ****************************************************************/
3936 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3937 {
3938    return ROK;
3939 }
3940
3941 /*******************************************************************
3942  *
3943  * @brief Builds PDSCH time domain allocation list
3944  *
3945  * @details
3946  *
3947  *    Function : BuildPdschTimeDomAllocList
3948  *
3949  *    Functionality: Builds PDSCH time domain allocation list
3950  *
3951  * @params[in]
3952  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3953  *
3954  * @return ROK     - success
3955  *         RFAILED - failure
3956  *
3957  * ****************************************************************/
3958    uint8_t BuildPdschTimeDomAllocList
3959 (
3960  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3961  )
3962 {
3963    uint8_t idx;
3964    uint8_t elementCnt;
3965    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3966
3967    timeDomAllocList->present = \
3968                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3969
3970    timeDomAllocList->choice.setup = NULLP;
3971    CU_ALLOC(timeDomAllocList->choice.setup, \
3972          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3973    if(!timeDomAllocList->choice.setup)
3974    {
3975       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3976       return RFAILED;
3977    }
3978
3979    elementCnt = 2;
3980    timeDomAllocList->choice.setup->list.count = elementCnt;
3981    timeDomAllocList->choice.setup->list.size = \
3982                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3983
3984    timeDomAllocList->choice.setup->list.array = NULLP;
3985    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3986          timeDomAllocList->choice.setup->list.size);
3987    if(!timeDomAllocList->choice.setup->list.array)
3988    {
3989       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3990       return RFAILED;
3991    }
3992
3993    for(idx = 0; idx < elementCnt; idx++)
3994    {
3995       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3996       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3997             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3998       if(!timeDomAllocList->choice.setup->list.array[idx])
3999       {
4000          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4001          return RFAILED;
4002       }
4003    }
4004
4005    idx = 0;
4006    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4007    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4008    if(!timeDomAlloc->k0)
4009    {
4010        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4011        return RFAILED;
4012    }
4013    *(timeDomAlloc->k0) = 0;
4014    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4015    timeDomAlloc->startSymbolAndLength = 66;
4016
4017    idx++;
4018    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4019    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4020    if(!timeDomAlloc->k0)
4021    {
4022       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4023       return RFAILED;
4024    }
4025    *(timeDomAlloc->k0) = 1;
4026    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4027    timeDomAlloc->startSymbolAndLength = 66;
4028
4029    return ROK;
4030 }
4031
4032 /*******************************************************************
4033  *
4034  * @brief Builds PDSCH PRB Bundling type
4035  *
4036  * @details
4037  *
4038  *    Function : BuildPdschPrbBundlingType
4039  *
4040  *    Functionality: Builds PDSCH PRB Bundling type
4041  *
4042  * @params[in]
4043  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4044  *
4045  * @return ROK     - success
4046  *         RFAILED - failure
4047  *
4048  * ****************************************************************/
4049    uint8_t BuildPdschPrbBundlingType
4050 (
4051  struct PDSCH_Config__prb_BundlingType *prbBndlType
4052  )
4053 {
4054    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4055
4056    prbBndlType->choice.staticBundling = NULLP;
4057    CU_ALLOC(prbBndlType->choice.staticBundling, \
4058          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4059    if(!prbBndlType->choice.staticBundling)
4060    {
4061       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4062       return RFAILED;
4063    }
4064    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4065
4066    return ROK;
4067 }
4068
4069 /*******************************************************************
4070  *
4071  * @brief Builds BWP DL dedicated PDSCH config
4072  *
4073  * @details
4074  *
4075  *    Function : BuildBWPDlDedPdschCfg
4076  *
4077  *    Functionality: Builds BWP DL dedicated PDSCH config
4078  *
4079  * @params[in] struct PDSCH_Config *pdschCfg
4080  *
4081  * @return ROK     - success
4082  *         RFAILED - failure
4083  *
4084  * ****************************************************************/
4085 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4086 {
4087    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4088
4089    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4090    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4091          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4092    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4093    {
4094       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4095       return RFAILED;
4096    }
4097
4098    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4099    {
4100       return RFAILED;
4101    }
4102
4103    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4104    pdschCfg->tci_StatesToAddModList = NULLP;
4105    pdschCfg->tci_StatesToReleaseList = NULLP;
4106    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4107 #if 0
4108    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4109    if(!pdschCfg->tci_StatesToAddModList)
4110    {
4111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4112       return RFAILED;
4113    }
4114    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4115    {
4116       return RFAILED;
4117    }
4118 #endif
4119
4120    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4121
4122    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4123    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4124          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4125    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4126    {
4127       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4128       return RFAILED;
4129    }
4130    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4131    {
4132       return RFAILED;
4133    }
4134    pdschCfg->pdsch_AggregationFactor = NULLP;
4135    pdschCfg->rateMatchPatternToAddModList = NULLP;
4136    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4137    pdschCfg->rateMatchPatternGroup1 = NULLP;
4138    pdschCfg->rateMatchPatternGroup2 = NULLP;
4139    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4140    pdschCfg->mcs_Table = NULLP;
4141
4142    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4143    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4144    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4145    {
4146       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4147       return RFAILED;
4148    }
4149    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4150
4151    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4152    {
4153       return RFAILED;
4154    }
4155
4156    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4157    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4158    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4159    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4160    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4161    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4162    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4163
4164    return ROK;
4165 }
4166
4167 /*******************************************************************
4168  *
4169  * @brief Builds intitial DL BWP
4170  * @details
4171  *
4172  *    Function : BuildInitialDlBWP
4173  *
4174  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4175  *
4176  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4177  *
4178  * @return ROK     - success
4179  *         RFAILED - failure
4180  *
4181  * ****************************************************************/
4182 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4183 {
4184    dlBwp->pdcch_Config = NULLP;
4185    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4186    if(!dlBwp->pdcch_Config)
4187    {
4188       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4189       return RFAILED;
4190    }
4191    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4192
4193    dlBwp->pdcch_Config->choice.setup = NULLP;
4194    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4195    if(!dlBwp->pdcch_Config->choice.setup)
4196    {
4197       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4198       return RFAILED;
4199    }
4200    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4201    {
4202       return RFAILED;
4203    }
4204
4205    dlBwp->pdsch_Config = NULLP;
4206    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4207    if(!dlBwp->pdsch_Config)
4208    {
4209       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4210       return RFAILED;
4211    }
4212    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4213
4214    dlBwp->pdsch_Config->choice.setup = NULLP;
4215    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4216    if(!dlBwp->pdsch_Config->choice.setup)
4217    {
4218       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4219       return RFAILED;
4220    }
4221
4222    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4223    {
4224       return RFAILED;
4225    }
4226
4227    dlBwp->sps_Config = NULLP;
4228    dlBwp->radioLinkMonitoringConfig = NULLP;
4229    return ROK;
4230 }
4231
4232 /*******************************************************************
4233  *
4234  * @brief Builds DMRS UL Pusch Mapping type A
4235  *
4236  * @details
4237  *
4238  *    Function : BuildDMRSULPuschMapTypeA
4239  *
4240  *    Functionality: Builds DMRS UL Pusch Mapping type A
4241  *
4242  * @params[in]
4243  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4244  * @return ROK     - success
4245  *         RFAILED - failure
4246  *
4247  * ****************************************************************/
4248    uint8_t BuildDMRSULPuschMapTypeA
4249 (
4250  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4251  )
4252 {
4253    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4254    dmrsUlCfg->choice.setup= NULLP;
4255    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4256    if(!dmrsUlCfg->choice.setup)
4257    {
4258       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4259       return RFAILED;
4260    }
4261
4262    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4263    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4264    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4265    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4266    {
4267       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4268       return RFAILED;
4269    }
4270    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4271
4272    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4273    dmrsUlCfg->choice.setup->maxLength = NULLP;
4274    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4275    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4276          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4277    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4278    {
4279       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4280       return RFAILED;
4281    }
4282
4283    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4284    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4285          sizeof(long));
4286    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4287    {
4288       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4289       return RFAILED;
4290    }
4291    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4292
4293    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4294    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4295    return ROK;
4296 }
4297
4298 /*******************************************************************
4299  *
4300  * @brief Build PUSCH time domain allocation list
4301  *
4302  * @details
4303  *
4304  *    Function : BuildPuschTimeDomAllocList
4305  *
4306  *    Functionality: Build PUSCH time domain allocation list
4307  *
4308  * @params[in]
4309  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4310  *
4311  * @return ROK     - success
4312  *         RFAILED - failure
4313  *
4314  * ****************************************************************/
4315    uint8_t BuildPuschTimeDomAllocList
4316 (
4317  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4318  )
4319 {
4320    uint8_t idx;
4321    uint8_t elementCnt;
4322    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4323
4324    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4325    timeDomAllocList->choice.setup = NULLP;
4326    CU_ALLOC(timeDomAllocList->choice.setup, \
4327          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4328    if(!timeDomAllocList->choice.setup)
4329    {
4330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4331       return RFAILED;
4332    }
4333
4334    elementCnt = 2;
4335    timeDomAllocList->choice.setup->list.count = elementCnt;
4336    timeDomAllocList->choice.setup->list.size = \
4337                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4338    timeDomAllocList->choice.setup->list.array = NULLP;
4339    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4340          timeDomAllocList->choice.setup->list.size);
4341    if(!timeDomAllocList->choice.setup->list.array)
4342    {
4343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4344       return RFAILED;
4345    }
4346
4347    for(idx = 0; idx < elementCnt; idx++)
4348    {
4349       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4350       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4351             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4352       if(!timeDomAllocList->choice.setup->list.array[idx])
4353       {
4354          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4355          return RFAILED;
4356       }
4357    }
4358
4359    idx = 0;
4360    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4361    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4362    if(!timeDomAlloc->k2)
4363    {
4364       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4365       return RFAILED;
4366    }
4367    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4368    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4369    timeDomAlloc->startSymbolAndLength = 66;
4370
4371    idx++;
4372    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4373    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4374    if(!timeDomAlloc->k2)
4375    {
4376        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4377        return RFAILED;
4378    }
4379    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4380    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4381    timeDomAlloc->startSymbolAndLength = 66;
4382
4383    return ROK;
4384 }
4385
4386 /*******************************************************************
4387  *
4388  * @brief Builds BWP UL dedicated PUSCH Config
4389  *
4390  * @details
4391  *
4392  *    Function : BuildBWPUlDedPuschCfg
4393  *
4394  *    Functionality:
4395  *      Builds BWP UL dedicated PUSCH Config
4396  *
4397  * @params[in] : PUSCH_Config_t *puschCfg
4398  *
4399  * @return ROK     - success
4400  *         RFAILED - failure
4401  *
4402  * ****************************************************************/
4403 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4404 {
4405    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4406    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4407    if(!puschCfg->dataScramblingIdentityPUSCH)
4408    {
4409       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4410       return RFAILED;
4411    }
4412    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4413
4414    puschCfg->txConfig = NULLP;
4415    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4416    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4417          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4418    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4419    {
4420       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4421       return RFAILED;
4422    }
4423
4424    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4425    {
4426       return RFAILED;
4427    }
4428
4429    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4430    puschCfg->pusch_PowerControl = NULLP;
4431    puschCfg->frequencyHopping = NULLP;
4432    puschCfg->frequencyHoppingOffsetLists = NULLP;
4433    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4434
4435    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4436    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4437          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4438    if(!puschCfg->pusch_TimeDomainAllocationList)
4439    {
4440       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4441       return RFAILED;
4442    }
4443
4444    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4445    {
4446       return RFAILED;
4447    }
4448
4449    puschCfg->pusch_AggregationFactor = NULLP;
4450    puschCfg->mcs_Table = NULLP;
4451    puschCfg->mcs_TableTransformPrecoder = NULLP;
4452    puschCfg->transformPrecoder = NULLP;
4453    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4454    if(!puschCfg->transformPrecoder)
4455    {
4456       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4457       return RFAILED;
4458    }
4459    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4460
4461    puschCfg->codebookSubset = NULLP;
4462    puschCfg->maxRank = NULLP;
4463    puschCfg->rbg_Size = NULLP;
4464    puschCfg->uci_OnPUSCH = NULLP;
4465    puschCfg->tp_pi2BPSK = NULLP;
4466
4467    return ROK;
4468 }
4469
4470 /*******************************************************************
4471  *
4472  * @brief Builds BWP UL dedicated PUCCH Config
4473  *
4474  * @details
4475  *
4476  *    Function : BuildBWPUlDedPucchCfg
4477  *
4478  *    Functionality:
4479  *      Builds BWP UL dedicated PUCCH Config
4480  *
4481  * @params[in] : PUCCH_Config_t *pucchCfg
4482  *
4483  * @return ROK     - success
4484  *         RFAILED - failure
4485  *
4486  * ****************************************************************/
4487 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4488 {
4489    uint8_t arrIdx, elementCnt;
4490    uint8_t rsrcIdx, rsrcSetIdx;
4491    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4492    PUCCH_Resource_t *rsrc = NULLP;
4493
4494    //RESOURCE SET
4495    elementCnt = 1;
4496    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4497    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4498    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4499    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4500    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4501    {
4502       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4503    }
4504    rsrcSetIdx = 0;
4505    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4506    rsrcSet->pucch_ResourceSetId = 1;
4507    elementCnt = 1;
4508    rsrcSet->resourceList.list.count = elementCnt;
4509    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4510    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4511    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4512    {
4513       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4514    }
4515    rsrcIdx = 0;
4516    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4517
4518    //RESOURCE
4519    elementCnt = 1;
4520    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4521    pucchCfg->resourceToAddModList->list.count = elementCnt;
4522    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4523    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4524    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4525    {
4526       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4527    }
4528    rsrcIdx = 0;
4529    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4530    rsrc->pucch_ResourceId = 1;
4531    rsrc->startingPRB = 0;
4532    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4533    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4534    rsrc->format.choice.format1->initialCyclicShift = 0;
4535    rsrc->format.choice.format1->nrofSymbols = 4;
4536    rsrc->format.choice.format1->startingSymbolIndex = 0;
4537    rsrc->format.choice.format1->timeDomainOCC = 0;
4538
4539    //PUCCH Format 1
4540    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4541    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4542    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4543    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4544    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4545
4546    //DL DATA TO UL ACK
4547    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4548    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4549    {
4550       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4551       return RFAILED;
4552    }
4553
4554    elementCnt = 2;
4555    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4556    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4557    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4558    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4559    {
4560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4561       return RFAILED;
4562    }
4563
4564    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4565    {
4566       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4567       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4568       {
4569           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4570           return RFAILED;
4571       }
4572    }
4573
4574    arrIdx = 0;
4575    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4576    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4577
4578    return ROK;
4579 }
4580
4581 /*******************************************************************
4582  *
4583  * @brief Fills SRS resource to add/modify list
4584  *
4585  * @details
4586  *
4587  *    Function : BuildSrsRsrcAddModList
4588  *
4589  *    Functionality: Fills SRS resource to add/modify list
4590  *
4591  * @params[in]
4592  * @return ROK     - success
4593  *         RFAILED - failure
4594  *
4595  * ****************************************************************/
4596 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4597 {
4598    uint8_t   elementCnt;
4599    uint8_t   rsrcIdx;
4600
4601    elementCnt = 1;
4602    resourceList->list.count = elementCnt;
4603    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4604    resourceList->list.array = NULLP;
4605    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4606    if(!resourceList->list.array)
4607    {
4608       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4609       return RFAILED;
4610    }
4611
4612    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4613    {
4614       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4615       if(!resourceList->list.array[rsrcIdx])
4616       {
4617          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4618          return RFAILED;
4619       }
4620    }
4621
4622    rsrcIdx = 0;
4623    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4624    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4625    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4626
4627    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4628    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4629          sizeof(struct SRS_Resource__transmissionComb__n2));
4630    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4631    {
4632       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4633       return RFAILED;
4634    }
4635    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4636       = SRS_COMB_OFFSET_N2;
4637    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4638       = SRS_CYCLIC_SHIFT_N2;
4639
4640    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4641    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4642                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4643    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4644                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4645
4646    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4647    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4648    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4649    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4650    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4651    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4652                                                                SRS_Resource__groupOrSequenceHopping_neither;
4653
4654    /* Setting resource type to aperiodic for intergration purposes */
4655    resourceList->list.array[rsrcIdx]->resourceType.present = \
4656                                                              SRS_Resource__resourceType_PR_aperiodic;
4657    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4658    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4659          sizeof(struct SRS_Resource__resourceType__aperiodic));
4660    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4661    {
4662       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4663       return RFAILED;
4664    }
4665    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4666
4667    return ROK;
4668 }
4669
4670 /*******************************************************************
4671  *
4672  * @brief Build SRS resource set Add/mod list
4673  *
4674  * @details
4675  *
4676  *    Function : BuildSrsRsrcSetAddModList
4677  *
4678  *    Functionality: Build SRS resource set Add/mod list
4679  *
4680  * @params[in]
4681  * @return ROK     - success
4682  *         RFAILED - failure
4683  *
4684  * ****************************************************************/
4685    uint8_t BuildSrsRsrcSetAddModList
4686 (
4687  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4688  )
4689 {
4690    uint8_t  elementCnt;
4691    uint8_t  rSetIdx;
4692    uint8_t  rsrcIdx;
4693    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4694
4695    elementCnt = 1;
4696    rsrcSetList->list.count = elementCnt;
4697    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4698    rsrcSetList->list.array = NULLP;
4699    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4700    if(!rsrcSetList->list.array)
4701    {
4702       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4703       return RFAILED;
4704    }
4705
4706    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4707    {
4708       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4709       if(!rsrcSetList->list.array[rSetIdx])
4710       {
4711          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4712          return RFAILED;
4713       }
4714    }
4715
4716    rSetIdx = 0;
4717    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4718
4719    /* Fill Resource Id list in resource set */
4720    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4721    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4722          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4723    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4724    {
4725       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4726       return RFAILED;
4727    }
4728
4729    elementCnt = 1;
4730    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4731    rsrcIdList->list.count = elementCnt;
4732    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4733    rsrcIdList->list.array = NULLP;
4734    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4735    if(!rsrcIdList->list.array)
4736    {
4737       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4738       return RFAILED;
4739    }
4740
4741    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4742    {
4743       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4744       if(!rsrcIdList->list.array[rsrcIdx])
4745       {
4746          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4747          return RFAILED;
4748       }
4749    }
4750
4751    rsrcIdx = 0;
4752    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4753
4754    /* Fill resource type */
4755    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4756                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4757
4758    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4759    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4760          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4761    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4762    {
4763       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4764       return RFAILED;
4765    }
4766    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4767       = APERIODIC_SRS_RESRC_TRIGGER;
4768
4769    /* TODO : Fill values for below IEs as expected by Viavi */
4770    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4771    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4772
4773
4774    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4775    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4776    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4777    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4778    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4779
4780    return ROK;
4781 }
4782
4783 /*******************************************************************
4784  *
4785  * @brief Builds BWP UL dedicated SRS Config
4786  *
4787  * @details
4788  *
4789  *    Function : BuildBWPUlDedSrsCfg
4790  *
4791  *    Functionality: Builds BWP UL dedicated SRS Config
4792  *
4793  * @params[in] SRS Config
4794  * @return ROK     - success
4795  *         RFAILED - failure
4796  *
4797  * ****************************************************************/
4798 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4799 {
4800    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4801    srsCfg->srs_ResourceSetToAddModList = NULLP;
4802    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4803          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4804    if(!srsCfg->srs_ResourceSetToAddModList)
4805    {
4806       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4807       return RFAILED;
4808    }
4809    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4810    {
4811       return RFAILED;
4812    }
4813
4814    srsCfg->srs_ResourceToReleaseList = NULLP;
4815
4816    /* Resource to Add/Modify list */
4817    srsCfg->srs_ResourceToAddModList = NULLP;
4818    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4819          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4820    if(!srsCfg->srs_ResourceToAddModList)
4821    {
4822       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4823       return RFAILED;
4824    }
4825
4826    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4827    {
4828       return RFAILED;
4829    }
4830
4831    srsCfg->tpc_Accumulation = NULLP;
4832
4833    return ROK;
4834 }
4835
4836 /*******************************************************************
4837  *
4838  * @brief Builds inital UL BWP
4839  *
4840  * @details
4841  *
4842  *    Function : BuildInitialUlBWP
4843  *
4844  *    Functionality: Builds initial UL BWP
4845  *
4846  * @params[in] BWP_UplinkDedicated_t *ulBwp
4847  * @return ROK     - success
4848  *         RFAILED - failure
4849  *
4850  * ****************************************************************/
4851 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4852 {
4853    ulBwp->pucch_Config = NULLP;
4854    ulBwp->pucch_Config = NULLP;
4855    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4856    if(!ulBwp->pucch_Config)
4857    {
4858       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4859       return RFAILED;
4860    }
4861
4862    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4863    ulBwp->pucch_Config->choice.setup = NULLP;
4864    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4865    if(!ulBwp->pucch_Config->choice.setup)
4866    {
4867       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4868       return RFAILED;
4869    }
4870
4871    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4872    {
4873       return RFAILED;
4874    }
4875
4876    /* Fill BWP UL dedicated PUSCH config */
4877    ulBwp->pusch_Config = NULLP;
4878    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4879    if(!ulBwp->pusch_Config)
4880    {
4881       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4882       return RFAILED;
4883    }
4884
4885    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4886    ulBwp->pusch_Config->choice.setup = NULLP;
4887    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4888    if(!ulBwp->pusch_Config->choice.setup)
4889    {
4890       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4891       return RFAILED;
4892    }
4893
4894    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4895    {
4896       return RFAILED;
4897    }
4898
4899    ulBwp->configuredGrantConfig = NULLP;
4900
4901    /* Fill BPW UL dedicated SRS config */
4902    ulBwp->srs_Config = NULLP;
4903    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4904    if(!ulBwp->srs_Config)
4905    {
4906       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4907       return RFAILED;
4908    }
4909
4910    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4911    ulBwp->srs_Config->choice.setup = NULLP;
4912    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4913    if(!ulBwp->srs_Config->choice.setup)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4916       return RFAILED;
4917    }
4918
4919    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4920    {
4921       return RFAILED;
4922    }
4923
4924    ulBwp->beamFailureRecoveryConfig = NULLP;
4925
4926    return ROK;
4927 }
4928
4929 /*******************************************************************
4930  *
4931  * @brief Builds Pusch Serving cell Config
4932  *
4933  * @details
4934  *
4935  *    Function : BuildPuschSrvCellCfg
4936  *
4937  *    Functionality: Builds Pusch Serving cell Config
4938  *
4939  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4940  *
4941  * @return ROK     - success
4942  *         RFAILED - failure
4943  *
4944  * ****************************************************************/
4945 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4946 {
4947    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4948    puschCfg->choice.setup = NULLP;
4949    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4950    if(!puschCfg->choice.setup)
4951    {
4952       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4953       return RFAILED;
4954    }
4955
4956    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4957    puschCfg->choice.setup->rateMatching = NULLP;
4958    puschCfg->choice.setup->xOverhead = NULLP;
4959    puschCfg->choice.setup->ext1 = NULLP;
4960    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4961    if(!puschCfg->choice.setup->ext1)
4962    {
4963       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4964       return RFAILED;
4965    }
4966
4967    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4968    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4969    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4970    {
4971       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4972       return RFAILED;
4973    }
4974    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4975
4976    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4977    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4978    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4979    {
4980       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4981       return RFAILED;
4982    }
4983    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4984    return ROK;
4985 }
4986
4987 /*******************************************************************
4988  *
4989  * @brief Builds UL config
4990  * @details
4991  *
4992  *    Function : BuildUlCfg
4993  *
4994  *    Functionality: Builds UL config in spCellCfgDed
4995  *
4996  * @params[in] UplinkConfig_t *ulCfg
4997  *
4998  * @return ROK     - success
4999  *         RFAILED - failure
5000  *
5001  * ****************************************************************/
5002 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
5003 {
5004    ulCfg->initialUplinkBWP = NULLP;
5005    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5006    if(!ulCfg->initialUplinkBWP)
5007    {
5008       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5009       return RFAILED;
5010    }
5011
5012    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
5013    {
5014       return RFAILED;
5015    }
5016
5017    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5018    ulCfg->uplinkBWP_ToAddModList = NULLP;
5019    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5020    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5021    if(!ulCfg->firstActiveUplinkBWP_Id)
5022    {
5023       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5024       return RFAILED;
5025    }
5026    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5027
5028    ulCfg->pusch_ServingCellConfig = NULLP;
5029    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
5030          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5031    if(!ulCfg->pusch_ServingCellConfig)
5032    {
5033       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5034       return RFAILED;
5035    }
5036
5037    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5038    {
5039       return RFAILED;
5040    }
5041
5042    ulCfg->carrierSwitching = NULLP;
5043    ulCfg->ext1 = NULLP;
5044    return ROK;
5045 }
5046
5047 /*******************************************************************
5048  *
5049  * @brief Builds PDSCH serving cell config
5050  * @details
5051  *
5052  *    Function : BuildPdschSrvCellCfg
5053  *
5054  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5055  *
5056  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5057  *
5058  * @return ROK     - success
5059  *         RFAILED - failure
5060  *
5061  * ****************************************************************/
5062 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5063 {
5064    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5065    pdschCfg->choice.setup = NULLP;
5066    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5067    if(!pdschCfg->choice.setup)
5068    {
5069       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5070       return RFAILED;
5071    }
5072
5073    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5074    pdschCfg->choice.setup->xOverhead = NULLP;
5075    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5076    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5077    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5078    {
5079       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5080       return RFAILED;
5081    }
5082    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5083    pdschCfg->choice.setup->pucch_Cell = NULLP;
5084    pdschCfg->choice.setup->ext1 = NULLP;
5085
5086    return ROK;
5087 }
5088
5089 /*******************************************************************
5090  *
5091  * @brief Builds CSI Meas config
5092  * @details
5093  *
5094  *    Function : BuildCsiMeasCfg
5095  *
5096  *    Functionality: Builds CSI Meas config in spCellCfgDed
5097  *
5098  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5099  *
5100  * @return ROK     - success
5101  *         RFAILED - failure
5102  *
5103  * ****************************************************************/
5104 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5105 {
5106
5107    return ROK;
5108 }
5109
5110 /*******************************************************************
5111  *
5112  * @brief Builds Spcell config dedicated
5113  * @details
5114  *
5115  *    Function : BuildSpCellCfgDed
5116  *
5117  *    Functionality: Builds sp cell config dedicated in spCellCfg
5118  *
5119  * @params[in] ServingCellConfig_t srvCellCfg
5120  *
5121  * @return ROK     - success
5122  *         RFAILED - failure
5123  *
5124  * ****************************************************************/
5125 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5126 {
5127    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5128
5129    srvCellCfg->initialDownlinkBWP = NULLP;
5130    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5131    if(!srvCellCfg->initialDownlinkBWP)
5132    {
5133       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5134       return RFAILED;
5135    }
5136
5137    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5138    {
5139       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5140       return RFAILED;
5141    }
5142    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5143    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5144
5145    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5146    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5147    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5148    {
5149       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5150       return RFAILED;
5151    }
5152    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5153
5154    srvCellCfg->bwp_InactivityTimer = NULLP;
5155
5156    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5157    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5158    if(!srvCellCfg->defaultDownlinkBWP_Id)
5159    {
5160       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5161       return RFAILED;
5162    }
5163    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5164
5165    srvCellCfg->uplinkConfig = NULLP;
5166    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5167    if(!srvCellCfg->uplinkConfig)
5168    {
5169       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5170       return RFAILED;
5171    }
5172
5173    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5174    {
5175       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5176       return RFAILED;
5177    }
5178    srvCellCfg->supplementaryUplink = NULLP;
5179    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5180
5181    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5182    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5183    if(!srvCellCfg->pdsch_ServingCellConfig)
5184    {
5185       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5186       return RFAILED;
5187    }
5188
5189    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5190    {
5191       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5192       return RFAILED;
5193    }
5194
5195    srvCellCfg->csi_MeasConfig = NULLP;
5196 #if 0
5197    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5198       if(!srvCellCfg->csi_MeasConfig)
5199       {
5200          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5201          return RFAILED;
5202       }
5203
5204    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5205    {
5206       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5207       return RFAILED;
5208    }
5209 #endif
5210    srvCellCfg->sCellDeactivationTimer = NULLP;
5211    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5212    srvCellCfg->tag_Id = TAG_ID;
5213    srvCellCfg->dummy = NULLP;
5214    srvCellCfg->pathlossReferenceLinking = NULLP;
5215    srvCellCfg->servingCellMO = NULLP;
5216    srvCellCfg->ext1 = NULLP;
5217
5218    return ROK;
5219 }
5220 /*******************************************************************
5221  *
5222  * @brief Builds Spcell config
5223  *
5224  * @details
5225  *
5226  *    Function : BuildSpCellCfg
5227  *
5228  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5229  *
5230  * @params[in] SpCellConfig_t spCellCfg
5231  *
5232  * @return ROK     - success
5233  *         RFAILED - failure
5234  *
5235  * ****************************************************************/
5236 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5237 {
5238
5239    spCellCfg->servCellIndex = NULLP;
5240    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5241    if(!spCellCfg->servCellIndex)
5242    {
5243       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5244       return RFAILED;
5245    }
5246    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5247
5248    spCellCfg->reconfigurationWithSync = NULLP;
5249    spCellCfg->rlf_TimersAndConstants = NULLP;
5250    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5251    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5252    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5253    {
5254       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5255       return RFAILED;
5256    }
5257    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5258
5259    spCellCfg->spCellConfigDedicated = NULLP;
5260    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5261    if(!spCellCfg->spCellConfigDedicated)
5262    {
5263       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5264       return RFAILED;
5265    }
5266    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5267    {
5268       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5269       return RFAILED;
5270    }
5271    return ROK;
5272 }
5273 /*******************************************************************
5274  *
5275  * @brief Builds Phy cell group config
5276  *
5277  * @details
5278  *
5279  *    Function : BuildPhyCellGrpCfg
5280  *
5281  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5282  *
5283  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5284  *
5285  * @return ROK     - success
5286  *         RFAILED - failure
5287  *
5288  * ****************************************************************/
5289 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5290 {
5291    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5292    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5293
5294    phyCellGrpCfg->p_NR_FR1 = NULLP;
5295    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5296    if(!phyCellGrpCfg->p_NR_FR1)
5297    {
5298       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5299       return RFAILED;
5300    }
5301    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5302    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5303    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5304    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5305    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5306    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5307    phyCellGrpCfg->cs_RNTI = NULLP;
5308    phyCellGrpCfg->ext1 = NULLP;
5309    phyCellGrpCfg->ext2 = NULLP;
5310
5311    return ROK;
5312 }
5313
5314 /*******************************************************************
5315  *
5316  * @brief Builds tag config
5317  *
5318  * @details
5319  *
5320  *    Function : BuildTagConfig
5321  *
5322  *    Functionality: Builds tag config in MacCellGroupConfig
5323  *
5324  * @params[in] TAG_Config *tag_Config
5325  *
5326  * @return ROK     - success
5327  *         RFAILED - failure
5328  *
5329  * ****************************************************************/
5330 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5331 {
5332    struct TAG_Config__tag_ToAddModList *tagList;
5333    uint8_t                     idx, elementCnt;
5334
5335    tagConfig->tag_ToReleaseList = NULLP;
5336    tagConfig->tag_ToAddModList = NULLP;
5337    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5338    if(!tagConfig->tag_ToAddModList)
5339    {
5340       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5341       return RFAILED;
5342    }
5343
5344    elementCnt = 1; //ODU_VALUE_ONE;
5345    tagList = tagConfig->tag_ToAddModList;
5346    tagList->list.count = elementCnt;
5347    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5348
5349    tagList->list.array = NULLP;
5350    CU_ALLOC(tagList->list.array, tagList->list.size);
5351    if(!tagList->list.array)
5352    {
5353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5354       return RFAILED;
5355    }
5356
5357    for(idx=0; idx<tagList->list.count; idx++)
5358    {
5359       tagList->list.array[idx] = NULLP;
5360       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5361       if(!tagList->list.array[idx])
5362       {
5363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5364          return RFAILED;
5365       }
5366    }
5367
5368    idx = 0;
5369    tagList->list.array[idx]->tag_Id = TAG_ID;
5370    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5371
5372    return ROK;
5373 }
5374
5375 /*******************************************************************
5376  *
5377  * @brief Builds PHR Config
5378  *
5379  * @details
5380  *
5381  *    Function : BuildPhrConfig
5382  *
5383  *    Functionality: Builds phrConfig in MacCellGroupConfig
5384  *
5385  * @params[in] PHR Config *
5386  *
5387  * @return ROK     - success
5388  *         RFAILED - failure
5389  *
5390  * ****************************************************************/
5391 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5392 {
5393
5394    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5395    phrConfig->choice.setup = NULLP;
5396    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5397    if(!phrConfig->choice.setup)
5398    {
5399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5400       return RFAILED;
5401    }
5402
5403    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5404    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5405    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5406    phrConfig->choice.setup->multiplePHR              = false;
5407    phrConfig->choice.setup->dummy                    = false;
5408    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5409    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5410
5411    return ROK;
5412 }
5413
5414 /*******************************************************************
5415  *
5416  * @brief Builds BSR Config
5417  *
5418  * @details
5419  *
5420  *    Function : BuildBsrConfig
5421  *
5422  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5423  *
5424  * @params[in] BSR_Config *bsrConfig
5425  *
5426  * @return ROK     - success
5427  *         RFAILED - failure
5428  *
5429  * ****************************************************************/
5430 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5431 {
5432    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5433    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5434    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5435
5436    return ROK;
5437 }
5438
5439 /*******************************************************************
5440  *
5441  * @brief Builds scheduling request config
5442  *
5443  * @details
5444  *
5445  *    Function : BuildSchedulingReqConfig
5446  *
5447  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5448  *
5449  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5450  *
5451  * @return ROK     - success
5452  *         RFAILED - failure
5453  *
5454  * ****************************************************************/
5455 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5456 {
5457    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5458    uint8_t                     idx, elementCnt;
5459
5460    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5461    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5462          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5463    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5464    {
5465       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5466       return RFAILED;
5467    }
5468
5469    elementCnt = 1; //ODU_VALUE_ONE;
5470    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5471    schReqList->list.count = elementCnt;
5472    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5473
5474    schReqList->list.array = NULLP;
5475    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5476    if(!schReqList->list.array)
5477    {
5478       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5479       return RFAILED;
5480    }
5481
5482    for(idx=0;idx<schReqList->list.count; idx++)
5483    {
5484       schReqList->list.array[idx] = NULLP;
5485       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5486       if(!schReqList->list.array[idx])
5487       {
5488          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5489          return RFAILED;
5490       }
5491    }
5492
5493    idx = 0;
5494    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5495
5496    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5497    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5498    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5499    {
5500       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5501       return RFAILED;
5502    }
5503    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5504    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5505    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5506
5507    return ROK;
5508 }
5509 /*******************************************************************
5510  *
5511  * @brief Builds Mac cell group config
5512  *
5513  * @details
5514  *
5515  *    Function : BuildMacCellGrpCfg
5516  *
5517  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5518  *
5519  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5520  *
5521  * @return ROK     - success
5522  *         RFAILED - failure
5523  *
5524  * ****************************************************************/
5525 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5526 {
5527    macCellGrpCfg->drx_ConfigRrc = NULLP;
5528    macCellGrpCfg->schedulingRequestConfig = NULLP;
5529    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5530    if(!macCellGrpCfg->schedulingRequestConfig)
5531    {
5532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5533       return RFAILED;
5534    }
5535
5536    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5537    {
5538       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5539       return RFAILED;
5540    }
5541
5542    macCellGrpCfg->bsr_Config = NULLP;
5543    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5544    if(!macCellGrpCfg->bsr_Config)
5545    {
5546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5547       return RFAILED;
5548    }
5549
5550    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5551    {
5552       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5553       return RFAILED;
5554    }
5555
5556    macCellGrpCfg->tag_Config = NULLP;
5557    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5558    if(!macCellGrpCfg->tag_Config)
5559    {
5560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5561       return RFAILED;
5562    }
5563
5564    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5565    {
5566       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5567       return RFAILED;
5568    }
5569
5570    macCellGrpCfg->phr_Config = NULLP;
5571    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5572    if(!macCellGrpCfg->phr_Config)
5573    {
5574       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5575       return RFAILED;
5576    }
5577
5578    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5579    {
5580       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5581       return RFAILED;
5582    }
5583
5584    macCellGrpCfg->skipUplinkTxDynamic = false;
5585    macCellGrpCfg->ext1 = NULLP;
5586
5587    return ROK;
5588 }
5589 /*******************************************************************
5590  *
5591  * @brief Frees memeory allocated for SearchSpcToAddModList
5592  *
5593  * @details
5594  *
5595  *    Function : FreeSearchSpcToAddModList
5596  *
5597  *    Functionality: Deallocating memory of SearchSpcToAddModList
5598  *
5599  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5600  *
5601  * @return void
5602  *
5603  4221 * ****************************************************************/
5604 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5605 {
5606    uint8_t idx1=0;
5607    uint8_t idx2=0;
5608    struct  SearchSpace *searchSpc=NULLP;
5609
5610    if(searchSpcList->list.array)
5611    {
5612       if(searchSpcList->list.array[idx2])
5613       {
5614          searchSpc = searchSpcList->list.array[idx2];
5615          if(searchSpc->controlResourceSetId)
5616          {
5617             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5618             {
5619                if(searchSpc->monitoringSymbolsWithinSlot)
5620                {
5621                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5622                   {
5623                      if(searchSpc->nrofCandidates)
5624                      {
5625                         if(searchSpc->searchSpaceType)
5626                         {
5627                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5628                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5629                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5630                                     SearchSpace__searchSpaceType));
5631                         }
5632                         CU_FREE(searchSpc->nrofCandidates,
5633                               sizeof(struct SearchSpace__nrofCandidates));
5634                      }
5635                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5636                            searchSpc->monitoringSymbolsWithinSlot->size);
5637                   }
5638                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5639                         sizeof(BIT_STRING_t));
5640                }
5641                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5642                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5643             }
5644             CU_FREE(searchSpc->controlResourceSetId,
5645                   sizeof(ControlResourceSetId_t));
5646          }
5647       }
5648       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5649       {
5650          CU_FREE(searchSpcList->list.array[idx1],
5651                sizeof(struct SearchSpace));
5652       }
5653       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5654    }
5655 }
5656 /*******************************************************************
5657  *
5658  * @brief Frees memory allocated for PdschTimeDomAllocList
5659  *
5660  * @details
5661  *
5662  *    Function : FreePdschTimeDomAllocList
5663  *
5664  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5665  *
5666  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5667  *
5668  * @return void
5669  *
5670  4221 * ****************************************************************/
5671 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5672 {
5673    uint8_t idx1=0;
5674
5675    if(timeDomAllocList->choice.setup)
5676    {
5677       if(timeDomAllocList->choice.setup->list.array)
5678       {
5679          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5680          {
5681             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5682                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5683          }
5684          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5685                timeDomAllocList->choice.setup->list.size);
5686       }
5687       CU_FREE(timeDomAllocList->choice.setup,\
5688             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5689    }
5690 }
5691 /*******************************************************************
5692  *
5693  * @brief Frees memory allocated for PuschTimeDomAllocList
5694  *
5695  *@details
5696  *
5697  *    Function : FreePuschTimeDomAllocList
5698  *
5699  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5700  *
5701  * @params[in] PUSCH_Config_t *puschCfg
5702  *
5703  * @return void
5704  *
5705  ***********************************************************************/
5706 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5707 {
5708    uint8_t idx1=0;
5709    uint8_t idx2=0;
5710    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5711
5712    if(puschCfg->pusch_TimeDomainAllocationList)
5713    {
5714       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5715       if(timeDomAllocList_t->choice.setup)
5716       {
5717          if(timeDomAllocList_t->choice.setup->list.array)
5718          {
5719             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5720             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5721             {
5722                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5723                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5724             }
5725             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5726                   timeDomAllocList_t->choice.setup->list.size);
5727          }
5728          CU_FREE(timeDomAllocList_t->choice.setup, \
5729                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5730       }
5731       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5732       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5733             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5734    }
5735
5736 }
5737
5738 /*******************************************************************
5739  *
5740  * @brief Frees memory allocated for Dedicated PUCCH config
5741  *
5742  * @details
5743  *
5744  *    Function : FreeBWPUlDedPucchCfg
5745  *
5746  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5747  *
5748  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5749  *
5750  * @return void
5751  *
5752  * ****************************************************************/
5753 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5754 {
5755    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5756    PUCCH_Config_t *pucchCfg = NULLP;
5757    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5758    PUCCH_Resource_t *rsrc = NULLP;
5759
5760    if(ulBwpPucchCfg)
5761    {
5762       if(ulBwpPucchCfg->choice.setup)
5763       {
5764          pucchCfg = ulBwpPucchCfg->choice.setup;
5765
5766          //Free resource set list
5767          if(pucchCfg->resourceSetToAddModList)
5768          {
5769             if(pucchCfg->resourceSetToAddModList->list.array)
5770             {
5771                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5772                {
5773                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5774                   if(rsrcSet->resourceList.list.array)
5775                   {
5776                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5777                      {
5778                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5779                      }
5780                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5781                   }
5782                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5783                }
5784                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5785             }
5786             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5787          }
5788
5789          //Free resource list
5790          if(pucchCfg->resourceToAddModList)
5791          {
5792             if(pucchCfg->resourceToAddModList->list.array)
5793             {
5794                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5795                {
5796                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5797                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5798                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5799                }
5800                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5801             }
5802             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5803          }
5804
5805          //PUCCH Format 1
5806          if(pucchCfg->format1)
5807          {
5808             if(pucchCfg->format1->choice.setup)
5809             {
5810                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5811                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5812             }
5813             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5814          }
5815
5816          //DL DATA TO UL ACK
5817          if(pucchCfg->dl_DataToUL_ACK)
5818          {
5819             if(pucchCfg->dl_DataToUL_ACK->list.array)
5820             {
5821                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5822                {
5823                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5824                }
5825                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5826             }
5827             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5828          }
5829
5830          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5831       }
5832       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5833    }
5834 }
5835
5836 /*******************************************************************
5837  *
5838  * @brief Frees memory allocated for InitialUlBWP
5839  *
5840  * @details
5841  *
5842  *    Function : FreeInitialUlBWP
5843  *
5844  *    Functionality: Deallocating memory of InitialUlBWP
5845  *
5846  * @params[in] BWP_UplinkDedicated_t *ulBwp
5847  *
5848  * @return void
5849  *
5850  * ****************************************************************/
5851 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5852 {
5853    uint8_t  rSetIdx, rsrcIdx;
5854    SRS_Config_t   *srsCfg = NULLP;
5855    PUSCH_Config_t *puschCfg = NULLP;
5856    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5857    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5858    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5859    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5860
5861    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5862
5863    if(ulBwp->pusch_Config)
5864    {
5865       if(ulBwp->pusch_Config->choice.setup)
5866       {
5867          puschCfg=ulBwp->pusch_Config->choice.setup;
5868          if(puschCfg->dataScramblingIdentityPUSCH)
5869          {
5870             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5871             {
5872                FreePuschTimeDomAllocList(puschCfg);
5873                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5874                if(dmrsUlCfg->choice.setup)
5875                {
5876                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5877                   {
5878                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5879                      {
5880                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5881                               sizeof(long));
5882                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5883                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5884                      }
5885                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5886                            sizeof(long));
5887                   }
5888                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5889                }
5890                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5891                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5892             }
5893             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5894          }
5895          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5896       }
5897       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5898
5899       /* Free SRS-Config */
5900       if(ulBwp->srs_Config)
5901       {
5902          if(ulBwp->srs_Config->choice.setup)
5903          {
5904             srsCfg = ulBwp->srs_Config->choice.setup;
5905
5906             /* Free Resource Set to add/mod list */
5907             if(srsCfg->srs_ResourceSetToAddModList)
5908             {
5909                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5910                if(rsrcSetList->list.array)
5911                {
5912                   rSetIdx = 0;
5913
5914                   /* Free SRS resource Id list in this SRS resource set */
5915                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5916                   {
5917                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5918
5919                      if(rsrcIdList->list.array)
5920                      {
5921                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5922                         {
5923                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5924                         }
5925                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5926                      }
5927                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5928                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5929                   }
5930
5931                   /* Free resource type info for this SRS resource set */
5932                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5933                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5934
5935                   /* Free memory for each resource set */
5936                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5937                   {
5938                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5939                   }
5940                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5941                }
5942                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5943                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5944             }
5945
5946             /* Free resource to add/modd list */
5947             if(srsCfg->srs_ResourceToAddModList)
5948             {
5949                resourceList = srsCfg->srs_ResourceToAddModList;
5950                if(resourceList->list.array)
5951                {
5952                   rsrcIdx = 0;
5953                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5954                         sizeof(struct SRS_Resource__transmissionComb__n2));
5955                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5956                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5957
5958                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5959                   {
5960                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5961                   }
5962                   CU_FREE(resourceList->list.array, resourceList->list.size);
5963                }
5964                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5965                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5966             }
5967
5968             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5969          }
5970          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5971       }
5972    }
5973 }
5974 /*******************************************************************
5975  *
5976  * @brief Frees memory allocated for initialUplinkBWP
5977  *
5978  * @details
5979  *
5980  *    Function : FreeinitialUplinkBWP
5981  *
5982  *    Functionality: Deallocating memory of initialUplinkBWP
5983  *
5984  * @params[in] UplinkConfig_t *ulCfg
5985  *
5986  * @return void
5987  *
5988  *
5989  * ****************************************************************/
5990 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5991 {
5992    BWP_UplinkDedicated_t *ulBwp=NULLP;
5993    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5994
5995    if(ulCfg->initialUplinkBWP)
5996    {
5997       ulBwp=ulCfg->initialUplinkBWP;
5998       if(ulCfg->firstActiveUplinkBWP_Id)
5999       {
6000          if(ulCfg->pusch_ServingCellConfig)
6001          {
6002             puschCfg=ulCfg->pusch_ServingCellConfig;
6003             if(puschCfg->choice.setup)
6004             {
6005                if(puschCfg->choice.setup->ext1)
6006                {
6007                   CU_FREE(puschCfg->choice.setup->ext1->\
6008                         processingType2Enabled,sizeof(BOOLEAN_t));
6009                   CU_FREE(puschCfg->choice.setup->ext1->\
6010                         maxMIMO_Layers,sizeof(long));
6011                   CU_FREE(puschCfg->choice.setup->ext1, \
6012                         sizeof(struct PUSCH_ServingCellConfig__ext1));
6013                }
6014                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6015             }
6016             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6017          }
6018          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6019       }
6020       FreeInitialUlBWP(ulBwp);
6021       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6022    }
6023 }
6024 /*******************************************************************
6025  *
6026  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6027  *
6028  * @details
6029  *
6030  *    Function : FreeBWPDlDedPdschCfg
6031  *
6032  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6033  *
6034  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6035  *
6036  * @return void
6037  *
6038  *
6039  * ****************************************************************/
6040 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6041 {
6042    struct PDSCH_Config *pdschCfg=NULLP;
6043    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6044    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6045    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6046
6047    if(dlBwp->pdsch_Config->choice.setup)
6048    {
6049       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6050       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6051       {
6052          if(pdschCfg->pdsch_TimeDomainAllocationList)
6053          {
6054             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6055             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6056             {
6057                prbBndlType=&pdschCfg->prb_BundlingType;
6058                CU_FREE(prbBndlType->choice.staticBundling,\
6059                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6060                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6061             }
6062             FreePdschTimeDomAllocList(timeDomAllocList);
6063             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6064                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6065          }
6066          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6067          if(dmrsDlCfg->choice.setup)
6068          {
6069             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6070                   sizeof(long));
6071             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6072          }
6073          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6074                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6075       }
6076       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6077    }
6078 }
6079 /*******************************************************************
6080  *
6081  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6082  *
6083  * @details
6084  *
6085  *    Function : FreeBWPDlDedPdcchCfg
6086  *
6087  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6088  *
6089  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6090  *
6091  * @return void
6092  *
6093  *
6094  * ****************************************************************/
6095 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6096 {
6097    uint8_t idx1=0;
6098    uint8_t idx2=0;
6099    struct PDCCH_Config *pdcchCfg=NULLP;
6100    struct ControlResourceSet *controlRSet=NULLP;
6101    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6102
6103    if(dlBwp->pdcch_Config->choice.setup)
6104    {
6105       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6106       if(pdcchCfg->controlResourceSetToAddModList)
6107       {
6108          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6109          if(controlRSetList->list.array)
6110          {
6111             controlRSet = controlRSetList->list.array[idx2];
6112             if(controlRSet)
6113             {
6114                if(controlRSet->frequencyDomainResources.buf)
6115                {
6116                   if(controlRSet->pdcch_DMRS_ScramblingID)
6117                   {
6118                      if(pdcchCfg->searchSpacesToAddModList)
6119                      {
6120                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6121                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
6122                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6123                      }
6124                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6125                   }
6126                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
6127                         controlRSet->frequencyDomainResources.size);
6128                }
6129             }
6130             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6131             {
6132                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6133             }
6134             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6135          }
6136          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6137                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6138       }
6139       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6140    }
6141 }
6142 /*******************************************************************
6143  *
6144  * @brief Builds RLC Config
6145  *
6146  * @details
6147  *
6148  *    Function : BuildRlcConfig
6149  *
6150  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
6151  *
6152  * @params[in] RLC_Config *rlcConfig
6153  *
6154  * @return ROK     - success
6155  *         RFAILED - failure
6156  *
6157  * ****************************************************************/
6158 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
6159 {
6160    rlcConfig->present = rlcLcCfgDb.rlcMode;
6161
6162    switch(rlcConfig->present)
6163    {
6164       case RLC_Config_PR_am:
6165          {
6166             rlcConfig->choice.am = NULLP;
6167             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6168             if(!rlcConfig->choice.am)
6169             {
6170                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6171                return RFAILED;
6172             }
6173
6174             /* UL */
6175             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
6176             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6177             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
6178             {
6179                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6180                return RFAILED;
6181             }
6182             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
6183             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
6184             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
6185             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
6186             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
6187
6188             /* DL */
6189             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
6190             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6191             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
6192             {
6193                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6194                return RFAILED;
6195             }
6196             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
6197             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
6198             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
6199
6200             break;
6201          }
6202
6203       case RLC_Config_PR_um_Bi_Directional:
6204          {
6205             rlcConfig->choice.um_Bi_Directional = NULLP;
6206             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
6207             if(!rlcConfig->choice.um_Bi_Directional)
6208             {
6209                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6210                return RFAILED;
6211             }
6212
6213             /* UL */
6214             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
6215             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6216             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
6217             {
6218                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6219                return RFAILED;
6220             }
6221             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
6222
6223             /* DL */
6224             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
6225             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6226             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
6227             {
6228                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6229                return RFAILED;
6230             }
6231             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
6232             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
6233             break;
6234          }
6235    }
6236    return ROK;
6237 }
6238
6239 /*******************************************************************
6240  *
6241  * @brief Builds MAC LC Config
6242  *
6243  * @details
6244  *
6245  *    Function : BuildMacLCConfig
6246  *
6247  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
6248  *
6249  * @params[in] struct LogicalChannelConfig macLcConfig
6250  *
6251  * @return ROK     - success
6252  *         RFAILED - failure
6253  *
6254  * ****************************************************************/
6255 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6256 {
6257
6258    macLcConfig->ul_SpecificParameters = NULLP;
6259    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6260    if(!macLcConfig->ul_SpecificParameters)
6261    {
6262       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6263       return RFAILED;
6264    }
6265
6266    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6267    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6268    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6269    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6270    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6271    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6272    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6273
6274    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6275    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6276    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6277    {
6278       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6279       return RFAILED;
6280    }
6281    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6282
6283    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6284    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6285    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6286    {
6287       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6288       return RFAILED;
6289    }
6290    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6291
6292    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6293    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6294    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6295
6296    return ROK;
6297 }
6298 /*******************************************************************
6299  *
6300  * @brief Builds RLC Bearer to Add/Mod list
6301  *
6302  * @details
6303  *
6304  *    Function :BuildRlcBearerToAddModList
6305  *
6306  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6307  *
6308  * @params[in] rlc_BearerToAddModList
6309  *
6310  * @return ROK     - success
6311  *         RFAILED - failure
6312  *
6313  * ****************************************************************/
6314 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6315 {
6316    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6317
6318    if(updateAllRbCfg)
6319       elementCnt = ueCb->numSrb + ueCb->numDrb;
6320    else
6321    {
6322       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6323       {
6324          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6325             elementCnt++;
6326       }
6327
6328       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6329       {
6330          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6331             elementCnt++;
6332       }
6333    }
6334
6335    if(!elementCnt)
6336    {
6337       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6338       return ROK;
6339    }
6340    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6341    if(!rlcBearerList)
6342    {
6343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6344       return RFAILED;
6345    }
6346    rlcBearerList->list.count = elementCnt;
6347    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6348
6349    rlcBearerList->list.array = NULLP;
6350    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6351    if(!rlcBearerList->list.array)
6352    {
6353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6354       return RFAILED;
6355    }
6356
6357    for(idx=0; idx<rlcBearerList->list.count; idx++)
6358    {
6359       rlcBearerList->list.array[idx] = NULLP;
6360       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6361       if(!rlcBearerList->list.array[idx])
6362       {
6363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6364          return RFAILED;
6365       }
6366    }
6367
6368    idx = 0;
6369
6370    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6371    {
6372       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6373          continue;
6374
6375       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6376
6377       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6378       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6379       {
6380          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6381          return RFAILED;
6382       }
6383
6384       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6385       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6386
6387       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6388       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6389       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6390       if(!rlcBearerList->list.array[idx]->rlc_Config)
6391       {
6392          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6393          return RFAILED;
6394       }
6395
6396       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6397       {
6398          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6399          return RFAILED;
6400       }
6401
6402       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6403       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6404       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6405       {
6406          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6407          return RFAILED;
6408       }
6409
6410       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6411       {
6412          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6413          return RFAILED;
6414       }
6415       idx++;
6416    }
6417
6418    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6419    {
6420       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6421          continue;
6422
6423       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6424
6425       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6426       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6427       {
6428          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6429          return RFAILED;
6430       }
6431
6432       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6433       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6434
6435       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6436       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6437       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6438       if(!rlcBearerList->list.array[idx]->rlc_Config)
6439       {
6440          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6441          return RFAILED;
6442       }
6443
6444       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6445       {
6446          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6447          return RFAILED;
6448       }
6449
6450       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6451       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6452       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6453       {
6454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6455          return RFAILED;
6456       }
6457
6458       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6459       {
6460          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6461          return RFAILED;
6462       }
6463       idx++;
6464    }
6465    return ROK;
6466 }
6467
6468 /*******************************************************************
6469  *
6470  * @brief Free memory allocated for CellGroupConfig
6471  *
6472  * @details
6473  *
6474  *    Function : FreeMemCellGrpCfg
6475  *
6476  *    Functionality: Deallocating memory of CellGroupConfig
6477  *
6478  * @params[in] pointer to CellGroupConfigRrc_t
6479  *
6480  * @return ROK     - success
6481  *         RFAILED - failure
6482  *
6483  ******************************************************************/
6484 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6485 {
6486    uint8_t idx=0;
6487    SpCellConfig_t *spCellCfg=NULLP;
6488    ServingCellConfig_t *srvCellCfg=NULLP;
6489    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6490    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6491    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6492    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6493    struct RLC_Config *rlcConfig=NULLP;
6494    struct LogicalChannelConfig *macLcConfig=NULLP;
6495    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6496    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6497    struct TAG_Config *tagConfig=NULLP;
6498    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6499    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6500    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6501
6502    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6503    if(rlcBearerList)
6504    {
6505       if(rlcBearerList->list.array)
6506       {
6507          for(idx=0; idx<rlcBearerList->list.count; idx++)
6508          {
6509             if(rlcBearerList->list.array[idx])
6510             {
6511                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6512                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6513                if(rlcConfig)
6514                {
6515                   if(rlcConfig->choice.am)
6516                   {
6517                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6518                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6519                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6520                   }
6521                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6522                }
6523                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6524                if(macLcConfig)
6525                {
6526                   if(macLcConfig->ul_SpecificParameters)
6527                   {
6528                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6529                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6530                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6531                   }
6532                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6533                }
6534                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6535             }
6536          }
6537          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6538       }
6539       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6540    }
6541
6542    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6543    if(macCellGrpCfg)
6544    {
6545       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6546       if(schedulingRequestConfig)
6547       {
6548          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6549          if(schReqList)
6550          {
6551             if(schReqList->list.array)
6552             {
6553                for(idx=0;idx<schReqList->list.count; idx++)
6554                {
6555                   if(schReqList->list.array[idx])
6556                   {
6557                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6558                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6559                   }
6560                }
6561                CU_FREE(schReqList->list.array, schReqList->list.size);
6562             }
6563             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6564                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6565             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6566       }
6567       if(macCellGrpCfg->bsr_Config)
6568       {
6569          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6570       }
6571       tagConfig = macCellGrpCfg->tag_Config;
6572       if(tagConfig)
6573       {
6574          tagList = tagConfig->tag_ToAddModList;
6575          if(tagList)
6576          {
6577             if(tagList->list.array)
6578             {
6579                for(idx=0; idx<tagList->list.count; idx++)
6580                {
6581                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6582                }
6583                CU_FREE(tagList->list.array, tagList->list.size);
6584             }
6585             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6586          }
6587          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6588       }
6589
6590       phrConfig = macCellGrpCfg->phr_Config;
6591       if(phrConfig)
6592       {
6593          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6594          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6595       }
6596
6597       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6598    }
6599
6600    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6601    if(phyCellGrpCfg)
6602    {
6603       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6604       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6605    }
6606
6607    spCellCfg = cellGrpCfg->spCellConfig;
6608    if(spCellCfg)
6609    {
6610       if(spCellCfg->servCellIndex)
6611       {
6612          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6613          {
6614             if(spCellCfg->spCellConfigDedicated)
6615             {
6616                srvCellCfg = spCellCfg->spCellConfigDedicated;
6617                if(srvCellCfg->initialDownlinkBWP)
6618                {
6619                   dlBwp = srvCellCfg->initialDownlinkBWP;
6620                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6621                   {
6622                      if(srvCellCfg->defaultDownlinkBWP_Id)
6623                      {
6624                         if(srvCellCfg->uplinkConfig)
6625                         {
6626                            if(srvCellCfg->pdsch_ServingCellConfig)
6627                            {
6628                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6629                               if(pdschCfg->choice.setup)
6630                               {
6631                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6632                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6633                               }
6634                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6635                                        ServingCellConfig__pdsch_ServingCellConfig));
6636                            }
6637                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6638                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6639                         }
6640                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6641                      }
6642                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6643                   }
6644                   if(dlBwp->pdcch_Config)
6645                   {
6646                      if(dlBwp->pdsch_Config)
6647                      {
6648                         FreeBWPDlDedPdschCfg(dlBwp);
6649                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6650                      }
6651                      FreeBWPDlDedPdcchCfg(dlBwp);
6652                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6653                   }
6654                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6655                }
6656                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6657             }
6658             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6659          }
6660          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6661       }
6662       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6663    }
6664    return ROK;
6665 }
6666
6667 /*******************************************************************
6668  *
6669  * @brief Fills CellGroupConfig
6670  *
6671  * @details
6672  *
6673  *    Function : fillCellGrpCfg
6674  *
6675  *    Functionality: Fills CellGroupConfig
6676  *
6677  * @params[in] pointer to CellGroupConfigRrc_t
6678  *
6679  * @return ROK     - success
6680  *         RFAILED - failure
6681  *
6682  ******************************************************************/
6683
6684 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6685 {
6686    uint8_t               ret = RFAILED;
6687    CellGroupConfigRrc_t  cellGrpCfg;
6688    asn_enc_rval_t        encRetVal;
6689
6690    while(true)
6691    {
6692       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6693
6694       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6695
6696       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6697       {
6698          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6699          break;
6700       }
6701
6702       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6703       cellGrpCfg.mac_CellGroupConfig = NULLP;
6704       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6705       if(!cellGrpCfg.mac_CellGroupConfig)
6706       {
6707          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6708          break;
6709       }
6710       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6711       {
6712          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6713          break;
6714       }
6715
6716       cellGrpCfg.physicalCellGroupConfig = NULLP;
6717       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6718       if(!cellGrpCfg.physicalCellGroupConfig)
6719       {
6720          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6721          break;
6722       }
6723       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6724       {
6725          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6726          break;
6727       }
6728
6729       cellGrpCfg.spCellConfig = NULLP;
6730       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6731       if(!cellGrpCfg.spCellConfig)
6732       {
6733          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6734          break;
6735       }
6736       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6737       {
6738          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6739          break;
6740       }
6741
6742       cellGrpCfg.sCellToAddModList = NULLP;
6743       cellGrpCfg.sCellToReleaseList = NULLP;
6744       cellGrpCfg.ext1 = NULLP;
6745
6746       /* encode cellGrpCfg into duToCuRrcContainer */
6747       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6748       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6749       encBufSize = 0;
6750       encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6751       /* Encode results */
6752       if(encRetVal.encoded == ENCODE_FAIL)
6753       {
6754          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6755                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6756          break;
6757       }
6758       else
6759       {
6760          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6761          for(int i=0; i< encBufSize; i++)
6762          {
6763             DU_LOG("%x",encBuf[i]);
6764          }
6765       }
6766
6767       cellGrp->size = encBufSize;
6768       CU_ALLOC(cellGrp->buf, cellGrp->size);
6769       if(!cellGrp->buf)
6770       {
6771          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6772          break;
6773       }
6774       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6775       ret = ROK;
6776       break;
6777    }
6778    FreeMemCellGrpCfg(&cellGrpCfg);
6779    return ret;
6780 }
6781
6782 /*******************************************************************
6783  *
6784  * @brief Free UE Capability RAT container
6785  *
6786  * @details
6787  *
6788  *    Function : freeUeCapRatCont
6789  *
6790  *    Functionality:
6791  *       Free UE Capability RAT conatiner
6792  *
6793  * @params[in]
6794  * @return ROK     - success
6795  *         RFAILED - failure
6796  *
6797  * ****************************************************************/
6798 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6799 {
6800    uint8_t idx;
6801    FeatureSets_t *featureSets;
6802
6803    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6804    {
6805       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6806       {
6807          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6808             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6809       }
6810       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6811    }
6812
6813    if(ueNrCap->featureSets)
6814    {
6815       featureSets = ueNrCap->featureSets;
6816       if(featureSets->featureSetsDownlinkPerCC)
6817       {
6818          if(featureSets->featureSetsDownlinkPerCC->list.array)
6819          {
6820             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6821             {
6822                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6823                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6824                         sizeof(ModulationOrder_t));
6825                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6826             }
6827             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6828          }
6829          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6830       }
6831
6832       if(featureSets->featureSetsUplinkPerCC)
6833       {
6834          if(featureSets->featureSetsUplinkPerCC->list.array)
6835          {
6836             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6837             {
6838                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6839                {
6840                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6841                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6842                          sizeof(ModulationOrder_t));
6843                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6844                }
6845             }
6846             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6847          }
6848          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6849       }
6850       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6851    }
6852 }
6853
6854 /*******************************************************************
6855  *
6856  * @brief Free UE capability RAT container list
6857  *
6858  * @details
6859  *
6860  *    Function : freeUeCapRatContList
6861  *
6862  *    Functionality: Free UE capability RAT container list
6863  *
6864  * @params[in]
6865  * @return ROK     - success
6866  *         RFAILED - failure
6867  *
6868  * ****************************************************************/
6869 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6870 {
6871    uint8_t idx;
6872    if(ueCapablityList->list.array)
6873    {
6874       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6875       {
6876          if(ueCapablityList->list.array[idx])
6877             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6878       }
6879       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6880    }
6881 }
6882
6883 /*******************************************************************
6884  *
6885  * @brief Free Handover preparation information
6886  *
6887  * @details
6888  *
6889  *    Function : freeHOPreparationInfo
6890  *
6891  *    Functionality: Free Handover preparation information
6892  *
6893  * @params[in]
6894  * @return ROK     - success
6895  *         RFAILED - failure
6896  *
6897  * ****************************************************************/
6898 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6899 {
6900    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6901
6902    if(hoPrep->criticalExtensions.choice.c1)
6903    {
6904       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6905       {
6906          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6907          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6908          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6909                sizeof(HandoverPreparationInformationRrc_IEs_t));
6910       }
6911       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6912    }
6913 }
6914
6915 /*******************************************************************
6916  *
6917  * @brief Fill feature sets
6918  *
6919  * @details
6920  *
6921  *    Function : fillFeatureSets
6922  *
6923  *    Functionality: Fill feature sets
6924  *
6925  * @params[in]
6926  * @return ROK     - success
6927  *         RFAILED - failure
6928  *
6929  * ****************************************************************/
6930 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6931 {
6932    uint8_t idx, elementCnt;
6933
6934    featureSets->featureSetsDownlink = NULLP;
6935    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6936    if(!featureSets->featureSetsDownlinkPerCC)
6937    {
6938       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6939       return RFAILED;
6940    }
6941
6942    elementCnt = 1;
6943    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6944    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6945    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6946    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6947    {
6948       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6949       return RFAILED;
6950    }
6951
6952    for(idx = 0; idx < elementCnt; idx++)
6953    {
6954       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6955       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6956       {
6957          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6958          return RFAILED;
6959       }
6960    }
6961
6962    idx = 0;
6963    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6964    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6965    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6966    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6967    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6968
6969    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6970    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6971    {
6972       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6973       return RFAILED;
6974    }
6975    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6976
6977    featureSets->featureSetsUplink = NULLP;
6978    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6979    if(!featureSets->featureSetsUplinkPerCC)
6980    {
6981       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6982       return RFAILED;
6983    }
6984
6985    elementCnt = 1;
6986    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6987    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6988    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6989    if(!featureSets->featureSetsUplinkPerCC->list.array)
6990    {
6991       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6992       return RFAILED;
6993    }
6994
6995    for(idx = 0; idx < elementCnt; idx++)
6996    {
6997       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6998       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6999       {
7000          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7001          return RFAILED;
7002       }
7003    }
7004
7005    idx = 0;
7006    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
7007    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
7008    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
7009    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
7010    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
7011    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
7012
7013    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
7014    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
7015    {
7016       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
7017       return RFAILED;
7018    }
7019    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
7020
7021    return ROK;
7022 }
7023
7024 /*******************************************************************
7025  *
7026  * @brief Fill UE capability RAT container
7027  *
7028  * @details
7029  *
7030  *    Function : fillUeCapRatCont
7031  *
7032  *    Functionality: Fill UE capability RAT container
7033  *
7034  * @params[in] UE Capability RAT container buffer
7035  * @return ROK     - success
7036  *         RFAILED - failure
7037  *
7038  * ****************************************************************/
7039 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
7040 {
7041    uint8_t             ret = ROK;
7042    uint8_t             idx, elementCnt;
7043    asn_enc_rval_t      encRetVal;
7044    UE_NR_Capability_t  ueNrCap;
7045
7046    while(true)
7047    {
7048       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
7049
7050       /* Filling PDCP parameters */
7051       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
7052       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
7053       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
7054       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
7055       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
7056       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
7057       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
7058       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
7059       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
7060       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
7061       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
7062       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
7063       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
7064       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
7065       ueNrCap.pdcp_Parameters.shortSN = NULLP;
7066       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
7067       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
7068
7069       ueNrCap.rlc_Parameters = NULLP;
7070       ueNrCap.mac_Parameters = NULLP;
7071
7072       /* Filling PHY parameters */
7073       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
7074       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
7075       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
7076       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
7077       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
7078
7079       /* Filling RF parameters */
7080       elementCnt = 1;
7081       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
7082       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
7083       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
7084       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
7085       {
7086          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
7087          ret = RFAILED;
7088          break;
7089       }
7090
7091       for(idx = 0; idx < elementCnt; idx++)
7092       {
7093          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
7094          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
7095          {
7096             ret = RFAILED;
7097             break;
7098          }
7099       }
7100       if(ret == RFAILED)
7101          break;
7102
7103       idx = 0;
7104       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
7105       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
7106       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
7107
7108       ueNrCap.measAndMobParameters = NULLP;
7109       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
7110       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
7111       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
7112       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
7113       ueNrCap.featureSets = NULLP;
7114
7115       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
7116       if(!ueNrCap.featureSets)
7117       {
7118          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
7119          ret = RFAILED;
7120          break;
7121       }
7122
7123       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
7124       {
7125          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
7126          ret = RFAILED;
7127          break;
7128       }
7129
7130       ueNrCap.featureSetCombinations = NULLP;
7131       ueNrCap.lateNonCriticalExtension = NULLP;
7132       ueNrCap.nonCriticalExtension = NULLP;
7133
7134       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7135       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
7136       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7137       encBufSize = 0;
7138       encRetVal = uper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
7139
7140       /* Encode results */
7141       if(encRetVal.encoded == ENCODE_FAIL)
7142       {
7143          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7144             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7145          break;
7146       }
7147       else
7148       {
7149          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7150          for(int i=0; i< encBufSize; i++)
7151          {
7152             DU_LOG("%x",encBuf[i]);
7153          }
7154       }
7155
7156       ueCapRatContBuf->size = encBufSize;
7157       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
7158       if(!ueCapRatContBuf->buf)
7159       {
7160          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7161          break;
7162       }
7163       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
7164       ret = ROK;
7165       break;
7166    }
7167    freeUeCapRatCont(&ueNrCap);
7168    return ROK;
7169 }
7170
7171 /*******************************************************************
7172  *
7173  * @brief Fill UE Capability RAT container list
7174  *
7175  * @details
7176  *
7177  *    Function : fillUeCapRatContList
7178  *
7179  *    Functionality: Fill UE Capability RAT container list
7180
7181  *
7182  * @params[in] UE capability RAT container list
7183  * @return ROK     - success
7184  *         RFAILED - failure
7185  *
7186  * ****************************************************************/
7187 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
7188 {
7189     uint8_t          ret = RFAILED;
7190     uint8_t          idx, elementCnt;
7191
7192     while(true)
7193     {
7194        elementCnt = 1;
7195        ueCapablityList->list.count = elementCnt;
7196        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
7197
7198        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
7199        if(!ueCapablityList->list.array)
7200        {
7201           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7202           ret = RFAILED;
7203           break;
7204        }
7205
7206        for(idx=0; idx<elementCnt; idx++)
7207        {
7208           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
7209           if(ueCapablityList->list.array[idx] == NULLP)
7210           {
7211              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7212              ret = RFAILED;
7213              break;
7214           }
7215        }
7216        idx = 0;
7217        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
7218        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
7219        {
7220           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
7221           ret = RFAILED;
7222           break;
7223        }
7224
7225        ret = ROK;
7226        break;
7227     }
7228     return ret;
7229 }
7230
7231 /*******************************************************************
7232  *
7233  * @brief Fill UE Capability RAT container list octet string
7234  *
7235  * @details
7236  *
7237  *    Function : fillUeCapRatContListBuf
7238  *
7239  *    Functionality: Fill UE Capability RAT container list octet string
7240
7241  *
7242  * @params[in] UE capability RAT container list buffer
7243  * @return ROK     - success
7244  *         RFAILED - failure
7245  *
7246  * ****************************************************************/
7247 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
7248 {
7249    uint8_t          ret = RFAILED;
7250    asn_enc_rval_t   encRetVal;
7251    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7252
7253    while(true)
7254    {
7255       ret = fillUeCapRatContList(&ueCapablityList);
7256       if(ret != ROK)
7257       {
7258          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7259          break;
7260       }
7261
7262       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7263       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7264       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7265       encBufSize = 0;
7266       encRetVal = uper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7267             &ueCapablityList, PrepFinalEncBuf, encBuf);
7268
7269       /* Encode results */
7270       if(encRetVal.encoded == ENCODE_FAIL)
7271       {
7272          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7273                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7274          break;
7275       }
7276       else
7277       {
7278          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7279          for(int i=0; i< encBufSize; i++)
7280          {
7281             DU_LOG("%x",encBuf[i]);
7282          }
7283       }
7284
7285       ueCapablityListBuf->size = encBufSize;
7286       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7287       if(!ueCapablityListBuf->buf)
7288       {
7289          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7290          break;
7291       }
7292       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7293       ret = ROK;
7294       break;
7295    }
7296    freeUeCapRatContList(&ueCapablityList);
7297    return ret;
7298 }
7299
7300 /*******************************************************************
7301  *
7302  * @brief Free Measurement Timing Configuration
7303  *
7304  * @details
7305  *
7306  *    Function : freeMeasuementTimingConfig
7307  *
7308  *    Functionality: Free Measurement Timing Configuration
7309  *
7310  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7311  * @return void
7312  *
7313  * ****************************************************************/
7314 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7315 {
7316    uint8_t measCfgIdx;
7317    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7318    MeasTiming_t *measTiming = NULLP;
7319
7320    if(measTimingConfig.criticalExtensions.choice.c1)
7321    {
7322       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7323       {
7324          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7325          if(measTimingCfg->measTiming)
7326          {
7327             if(measTimingCfg->measTiming->list.array)
7328             {
7329                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7330                {
7331                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7332                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7333                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7334                }
7335                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7336             }
7337             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7338          }
7339          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7340       }
7341       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7342    }
7343 }
7344
7345 /*******************************************************************
7346  *
7347  * @brief Fill Measurement Timing Configuration
7348  *
7349  * @details
7350  *
7351  *    Function : fillMeasTimingCfg
7352  *
7353  *    Functionality: Fill Measurement Timing Configuration
7354  *
7355  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7356  * @return ROK     - success
7357  *         RFAILED - failure
7358  *
7359  * ****************************************************************/
7360 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7361 {
7362    uint8_t elementCnt = 0;
7363    uint8_t measCfgIdx = 0;
7364    MeasTiming_t *measTiming;
7365    SSB_MTC_t *smtc;
7366
7367    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7368    if(!measTimingCfg->measTiming)
7369    {
7370       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7371       return RFAILED;
7372    }
7373
7374    elementCnt = 1;
7375    measTimingCfg->measTiming->list.count = elementCnt;
7376    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7377    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7378    if(!measTimingCfg->measTiming->list.array)
7379    {
7380       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7381       return RFAILED;
7382    }
7383
7384    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7385    {
7386       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7387       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7388       {
7389          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7390          return RFAILED;
7391       }
7392    }
7393
7394    measCfgIdx = 0;
7395    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7396    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7397    if(!measTiming->frequencyAndTiming)
7398    {
7399       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7400       return RFAILED;
7401    }
7402
7403    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7404    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7405
7406    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7407    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7408    smtc->periodicityAndOffset.choice.sf20 = 0;
7409    smtc->duration = SSB_MTC__duration_sf1;
7410    return ROK;
7411 }
7412
7413 /*******************************************************************
7414  *
7415  * @brief Fill Measurement Timing Configuration Octet string
7416  *
7417  * @details
7418  *
7419  *    Function : fillMeasConfigBuf
7420  *
7421  *    Functionality: Fill Measurement Timing Configuration Octet string
7422
7423  *
7424  * @params[in] MeasConfig_t *measConfgBuf
7425  * @return ROK     - success
7426  *         RFAILED - failure
7427  *
7428  * ****************************************************************/
7429 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7430 {
7431    uint8_t          ret = RFAILED;
7432    asn_enc_rval_t   encRetVal;
7433    MeasurementTimingConfigurationRrc_t measTimingConfig;
7434
7435    while(true)
7436    {
7437       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7438       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7439       if(!measTimingConfig.criticalExtensions.choice.c1)
7440       {
7441          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7442          return RFAILED;
7443       }
7444       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7445
7446       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7447       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7448       {
7449          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7450          return RFAILED;
7451       }
7452
7453       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7454       if(ret != ROK)
7455       {
7456          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7457          break;
7458       }
7459
7460       /* Encode measurement timing configuration into octet string */
7461       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7462       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7463       encBufSize = 0;
7464       encRetVal = uper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7465
7466       /* Encode results */
7467       if(encRetVal.encoded == ENCODE_FAIL)
7468       {
7469          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7470                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7471          break;
7472       }
7473       else
7474       {
7475          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7476          for(int i=0; i< encBufSize; i++)
7477          {
7478             DU_LOG("%x",encBuf[i]);
7479          }
7480       }
7481
7482       measTimingConfigBuf->size = encBufSize;
7483       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7484       if(!measTimingConfigBuf->buf)
7485       {
7486          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7487          break;
7488       }
7489       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7490       ret = ROK;
7491       break;
7492    }
7493    freeMeasuementTimingConfig(measTimingConfig);
7494    return ret;
7495 }
7496
7497 /******************************************************************
7498  *
7499  * @brief Free RRC reconfiguration non-critical extension
7500  *
7501  * @details
7502  *
7503  *    Function : freeRrcReconfigNonCriticalExt
7504  *
7505  *    Functionality: Free RRC reconfiguration non-critical extension
7506  *
7507  * @params[in] RRC reconfiguration IE
7508  * @return void
7509  *
7510  * ****************************************************************/
7511 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7512 {
7513    if(rrcRecfg->masterCellGroup)
7514    {
7515       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7516    }
7517 }
7518
7519 /******************************************************************
7520  *
7521  * @brief Free measurement object addmod list
7522  *
7523  * @details
7524  *
7525  *    Function : freeMeasObjToAddModList
7526  *
7527  *    Functionality: Free measurement object add mod list
7528  *
7529  * @params[in] Measurement object add/mod list
7530  * @return void
7531  *
7532  * ****************************************************************/
7533 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7534 {
7535    uint8_t objIdx;
7536    MeasObjectNR_t *measObject;
7537
7538    if(measObjList->list.array)
7539    {
7540       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7541       {
7542          if(measObjList->list.array[objIdx])
7543          {
7544             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7545             {
7546                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7547                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7548                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7549                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7550                if(measObject->absThreshSS_BlocksConsolidation)
7551                {
7552                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7553                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7554                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7555                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7556                }
7557                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7558                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7559                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7560                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7561                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7562             }
7563             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7564          }
7565       }
7566       CU_FREE(measObjList->list.array, measObjList->list.size);
7567    }
7568 }
7569
7570 /******************************************************************
7571  *
7572  * @brief Free report config add mod list
7573  *
7574  * @details
7575  *
7576  *    Function : freeReportCfgToAddModList
7577  *
7578  *    Functionality: Free report config add mod list
7579  *
7580  * @params[in] Report config list
7581  * @return void
7582  *
7583  * ****************************************************************/
7584 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7585 {
7586    uint8_t reportCfgIdx;
7587    ReportConfigToAddMod_t *reportCfg;
7588    ReportConfigNR_t *reportCfgNr;
7589    EventTriggerConfig_t *eventTriggCfg;
7590
7591    if(reportCfgList->list.array)
7592    {
7593       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7594       {
7595          if(reportCfgList->list.array[reportCfgIdx])
7596          {
7597             reportCfg = reportCfgList->list.array[reportCfgIdx];
7598             if(reportCfg->reportConfig.choice.reportConfigNR)
7599             {
7600                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7601                if(reportCfgNr->reportType.choice.eventTriggered)
7602                {
7603                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7604                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7605                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7606                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7607                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7608                }
7609             }
7610          }
7611          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7612       }
7613       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7614    }
7615 }
7616
7617 /******************************************************************
7618  *
7619  * @brief Free measurement id to add mod list
7620  *
7621  * @details
7622  *
7623  *    Function : freeMeasIdToAddModList
7624  *
7625  *    Functionality: Free measurement id to add mod list
7626  *
7627  * @params[in] Measurement id to add mod list
7628  * @return void
7629  *
7630  * ****************************************************************/
7631 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7632 {
7633    uint8_t measIdIdx;
7634    if(measIdList->list.array)
7635    {
7636       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7637       {
7638          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7639       }
7640       CU_FREE(measIdList->list.array, measIdList->list.size);
7641    }
7642 }
7643
7644 /*******************************************************************
7645  *
7646  * @brief Free quantity config
7647  *
7648  * @details
7649  *
7650  *    Function : freeQunatityConfig
7651  *
7652  *    Functionality: Free quantity config
7653  *
7654  * @params[in] Quantity Config
7655  * @return void
7656  *
7657  * ****************************************************************/
7658 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7659 {
7660    uint8_t quanCfgIdx;
7661    QuantityConfigNR_t *quantityCfgNr;
7662
7663    if(quantityCfg->quantityConfigNR_List)
7664    {
7665       if(quantityCfg->quantityConfigNR_List->list.array)
7666       {
7667          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7668          {
7669             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7670             {
7671                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7672                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7673                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7674                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7675                if(quantityCfgNr->quantityConfigRS_Index)
7676                {
7677                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7678                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7679                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7680                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7681                }
7682                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7683             }
7684          }
7685          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7686       }
7687       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7688    }
7689 }
7690
7691 /******************************************************************
7692  *
7693  * @brief Free measurement Config
7694  *
7695  * @details
7696  *
7697  *    Function : freeMeasConfig
7698  *
7699  *    Functionality: Free measurement config
7700  *
7701  * @params[in] Measurement config
7702  * @return void
7703  *
7704  * ****************************************************************/
7705 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7706 {
7707    if(measConfig->measObjectToAddModList)
7708    {
7709       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7710       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7711    }
7712    if(measConfig->reportConfigToAddModList)
7713    {
7714       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7715       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7716    }
7717    if(measConfig->measIdToAddModList)
7718    {
7719       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7720       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7721    }
7722    if(measConfig->s_MeasureConfig)
7723    {
7724       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7725    }
7726    if(measConfig->quantityConfig)
7727    {
7728       freeQuantityConfig(measConfig->quantityConfig);
7729       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7730    }
7731 }
7732 /******************************************************************
7733  *
7734  * @brief Free DRB to AddMod List
7735  *
7736  * @details
7737  *
7738  *    Function : freeDrbToAddModList
7739  *
7740  *    Functionality: Free SRB to AddMod List
7741  *
7742  * @params[in] SBR to add/mod list
7743  * @return void
7744  *
7745  * ****************************************************************/
7746 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7747 {
7748    uint8_t drbIdx;
7749    if(drbToAddList->list.array)
7750    {
7751       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7752       {
7753          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7754          {
7755             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7756             {
7757                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7758                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7759                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7760                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7761             }
7762             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7763             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7764          }
7765          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7766       }
7767       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7768    }
7769 }
7770
7771 /******************************************************************
7772  *
7773  * @brief Free SRB to AddMod List
7774  *
7775  * @details
7776  *
7777  *    Function : freeSrbToAddModList
7778  *
7779  *    Functionality: Free SRB to AddMod List
7780  *
7781  * @params[in] SBR to add/mod list
7782  * @return void
7783  *
7784  * ****************************************************************/
7785 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7786 {
7787    uint8_t srbIdx;
7788    if(srbToAddList->list.array)
7789    {
7790       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7791       {
7792          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7793          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7794          {
7795             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7796             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7797          }
7798
7799          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7800       }
7801       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7802    }
7803 }
7804
7805 /******************************************************************
7806  *
7807  * @brief Free Radio Bearer Config
7808  *
7809  * @details
7810  *
7811  *    Function : freeRadioBearerConfig
7812  *
7813  *    Functionality: Free Radio Bearer config
7814  *
7815  * @params[in] Radio bearer config
7816  * @return void
7817  *
7818  * ****************************************************************/
7819 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7820 {
7821    if(radioBearerConfig->srb_ToAddModList)
7822    {
7823       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7824       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7825    }
7826    if(radioBearerConfig->drb_ToAddModList)
7827    {
7828       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7829       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7830    }
7831 }
7832
7833 /******************************************************************
7834  *
7835  * @brief Free reconfiguration message
7836  *
7837  * @details
7838  *
7839  *    Function : freeRrcReconfig
7840  *
7841  *    Functionality: Free reconfiguration message
7842  *
7843  * @params[in] RRC Reconfiguration message
7844  * @return void
7845  *
7846  * ****************************************************************/
7847 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7848 {
7849    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7850    {
7851       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7852       {
7853          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7854          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7855       }
7856       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7857       {
7858          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7859          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7860       }
7861       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7862       {
7863          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7864          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7865       }
7866       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7867    }
7868 }
7869
7870 /******************************************************************
7871  *
7872  * @brief Fill SRB To Add Mod list
7873  *
7874  * @details
7875  *
7876  *    Function : fillSrbToAddModList
7877  *
7878  *    Functionality: fill SRB to Add Mod list
7879  *
7880  * @params[in] UE control block
7881  *             SRB to Add/Mod list
7882  * @return ROK     - success
7883  *         RFAILED - failure
7884  *
7885  * ****************************************************************/
7886 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7887 {
7888    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7889
7890    if(updateAllRbCfg)
7891       elementCnt = ueCb->numSrb;
7892    else
7893    {
7894       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7895       {
7896          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7897             elementCnt++;
7898       }
7899    }
7900
7901    if(!elementCnt)
7902    {
7903       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7904       return ROK;
7905    }
7906
7907    srbToAddList->list.count = elementCnt;
7908    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7909
7910    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7911    if(!srbToAddList->list.array)
7912    {
7913       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7914       return RFAILED;
7915    }
7916
7917    srbIdx = 0;
7918    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7919    {
7920       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7921          continue;
7922
7923       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7924       if(!srbToAddList->list.array[srbIdx])
7925       {
7926          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7927          return RFAILED;
7928       }
7929
7930       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7931
7932       /* Reestablish PDCP */
7933       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7934       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7935       {
7936          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7937          return RFAILED;
7938       }
7939       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7940
7941       /* PDCP configuration */
7942       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7943       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7944       {
7945          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7946          return RFAILED;
7947       }
7948
7949       /* Reordering timer */
7950       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7951       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7952       {
7953          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7954          return RFAILED;
7955       }
7956       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7957
7958       srbIdx++;
7959    }
7960    return ROK;
7961 }
7962
7963 /******************************************************************
7964  *
7965  * @biief Fill DRBeTo Add Mod list
7966  *
7967  * @details
7968  *
7969  *    Function : fillDrbToAddModList
7970  *
7971  *    Functionality: fill DRB to Add Mod list
7972  *
7973  * @params[in] UE control block
7974  *             DRB to Add/Mod list
7975  * @return ROK     - success
7976  *         RFAILED - failure
7977  *
7978  * ****************************************************************/
7979 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7980 {
7981    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7982
7983    if(updateAllRbCfg)
7984       elementCnt = ueCb->numDrb;
7985    else
7986    {
7987       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7988       {
7989          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7990             elementCnt++;
7991       }
7992    }
7993
7994    if(!elementCnt)
7995    {
7996       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7997       return ROK;
7998    }
7999
8000
8001    drbToAddList->list.count = elementCnt;
8002    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
8003
8004    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
8005    if(!drbToAddList->list.array)
8006    {
8007       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
8008       return RFAILED;
8009    }
8010
8011    drbIdx = 0;
8012    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
8013    {
8014       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
8015          continue;
8016
8017       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
8018       if(!drbToAddList->list.array[drbIdx])
8019       {
8020          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
8021          return RFAILED;
8022       }
8023
8024       /* DRB Id */
8025       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
8026
8027       /* PDCP Config */
8028       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
8029       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
8030       {
8031          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
8032          return RFAILED;
8033       }
8034
8035       /* PDCP Config -> DRB */
8036       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
8037       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
8038       {
8039          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
8040          return RFAILED;
8041       }
8042
8043       /* DRB -> Discard Timer */
8044       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
8045       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
8046       {
8047          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
8048          return RFAILED;
8049       }
8050       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
8051
8052       /* UL PDCP SN length */
8053       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
8054       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
8055       {
8056          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
8057          return RFAILED;
8058       }
8059       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
8060
8061       /* DL PDCP SN length */
8062       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
8063       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
8064       {
8065          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
8066          return RFAILED;
8067       }
8068       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
8069
8070       /* Header Compression */
8071       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
8072        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
8073
8074       /* Reordering timer */
8075       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
8076       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
8077       {
8078          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
8079          return RFAILED;
8080       }
8081       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
8082
8083       drbIdx++;
8084    }
8085
8086    return ROK;
8087 }
8088
8089 /******************************************************************
8090  *
8091  * @brief Fill Radio bearer configuration
8092  *
8093  * @details
8094  *
8095  *    Function : fillRadioBearerConfig
8096  *
8097  *    Functionality: Fill Radio bearer configuration
8098  *
8099  * @params[in] UE control block
8100  *             Radio bearer config pointer
8101  * @return ROK     - success
8102  *         RFAILED - failure
8103  *
8104  * ****************************************************************/
8105 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
8106 {
8107    /* SRB To Add/Mod List */
8108    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
8109    if(!radioBearerConfig->srb_ToAddModList)
8110    {
8111       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
8112       return RFAILED;
8113    }
8114    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
8115    {
8116       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
8117       return RFAILED;
8118    }
8119
8120    /* DRB To Add/Mod List */
8121    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
8122    if(!radioBearerConfig->drb_ToAddModList)
8123    {
8124       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
8125       return RFAILED;
8126     }
8127    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
8128    {
8129       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
8130       return RFAILED;
8131    }
8132
8133    return ROK;
8134 }
8135
8136 /*******************************************************************
8137  *
8138  * @brief Fill measurement object to add/mod list
8139  *
8140  * @details
8141  *
8142  *    Function : fillMeasObjToAddModList
8143  *
8144  *    Functionality: Fill measurement object to add/mod list
8145  *
8146  * @params[in] Measurement object to add/mod list
8147  * @return ROK     - success
8148  *         RFAILED - failure
8149  *
8150  * ****************************************************************/
8151 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
8152 {
8153    uint8_t elementCnt, objIdx;
8154    MeasObjectNR_t *measObject;
8155
8156    elementCnt = 1;
8157    measObjList->list.count = elementCnt;
8158    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
8159
8160    CU_ALLOC(measObjList->list.array, measObjList->list.size);
8161    if(!measObjList->list.array)
8162    {
8163       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
8164       return RFAILED;
8165    }
8166
8167    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
8168    {
8169       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
8170       if(!measObjList->list.array[objIdx])
8171       {
8172          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
8173          return RFAILED;
8174       }
8175    }
8176
8177    objIdx = 0;
8178    measObjList->list.array[objIdx]->measObjectId = 1;
8179    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
8180    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
8181    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
8182    {
8183       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
8184       return RFAILED;
8185    }
8186
8187    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
8188
8189    /* SSB frequency */
8190    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
8191    if(!measObject->ssbFrequency)
8192    {
8193       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
8194       return RFAILED;
8195    }
8196    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
8197
8198    /* Subcarrier spacing */
8199    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8200    if(!measObject->ssbSubcarrierSpacing)
8201    {
8202       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
8203       return RFAILED;
8204    }
8205    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
8206
8207    /* SMTC1 */
8208    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
8209    if(!measObject->smtc1)
8210    {
8211       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
8212       return RFAILED;
8213    }
8214    measObject->smtc1->duration = SSB_MTC__duration_sf1;
8215    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
8216    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
8217
8218    /* Absoulute threshold SSB consolidation */
8219    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
8220    if(!measObject->absThreshSS_BlocksConsolidation)
8221    {
8222       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
8223       return RFAILED;
8224    }
8225
8226    /* RSRP threshold */
8227    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
8228    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
8229    {
8230       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
8231       return RFAILED;
8232    }
8233    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
8234
8235    /* RSRQ threshold */
8236    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
8237    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
8238    {
8239       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
8240       return RFAILED;
8241    }
8242    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
8243
8244    /* SINR threshold */
8245    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
8246    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
8247    {
8248       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
8249       return RFAILED;
8250    }
8251    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8252
8253    /* Number of SSBs to average */
8254    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8255    if(!measObject->nrofSS_BlocksToAverage)
8256    {
8257       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8258       return RFAILED;
8259    }
8260    *(measObject->nrofSS_BlocksToAverage) = 2;
8261
8262    /* Quantity Config index */
8263    measObject->quantityConfigIndex = 1;
8264
8265    /* Offset MO */
8266    /* RSRP offset for SSB */
8267    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8268    if(!measObject->offsetMO.rsrpOffsetSSB)
8269    {
8270       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8271       return RFAILED;
8272    }
8273    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8274
8275    /* RSRQ offset for SSB */
8276    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8277    if(!measObject->offsetMO.rsrqOffsetSSB)
8278    {
8279       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8280       return RFAILED;
8281    }
8282    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8283
8284    /* SINR offset for SSB */
8285    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8286    if(!measObject->offsetMO.sinrOffsetSSB)
8287    {
8288       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8289       return RFAILED;
8290    }
8291    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8292
8293    return ROK;
8294 }
8295
8296 /*******************************************************************
8297  *
8298  * @brief Fill Report configuration to Add/mod list
8299  *
8300  * @details
8301  *
8302  *    Function : fillReportCfgToAddModList
8303  *
8304  *    Functionality: Fill Report configuration to Add/mod list
8305  *
8306  * @params[in] Report Config To Add/Mod List
8307  * @return ROK     - success
8308  *         RFAILED - failure
8309  *
8310  * ****************************************************************/
8311 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8312 {
8313    uint8_t elementCnt;
8314    uint8_t reportCfgIdx;
8315    ReportConfigToAddMod_t *reportCfg;
8316    ReportConfigNR_t *reportCfgNr;
8317    EventTriggerConfig_t *eventTriggCfg;
8318
8319    elementCnt = 1;
8320    reportCfgList->list.count = elementCnt;
8321    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8322
8323    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8324    if(!reportCfgList->list.array)
8325    {
8326       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8327       return RFAILED;
8328    }
8329
8330    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8331    {
8332       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8333       if(!reportCfgList->list.array[reportCfgIdx])
8334       {
8335          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8336          return RFAILED;
8337       }
8338    }
8339
8340    reportCfgIdx = 0;
8341    reportCfg = reportCfgList->list.array[reportCfgIdx];
8342    reportCfg->reportConfigId = 1;
8343    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8344
8345    /* Report Configuration for NR */
8346    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8347    if(!reportCfg->reportConfig.choice.reportConfigNR)
8348    {
8349       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8350       return RFAILED;
8351    }
8352    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8353
8354    /* Report Type */
8355    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8356    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8357    if(!reportCfgNr->reportType.choice.eventTriggered)
8358    {
8359       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8360       return RFAILED;
8361    }
8362    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8363
8364    /* Event 3 */
8365    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8366    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8367    if(!eventTriggCfg->eventId.choice.eventA3)
8368    {
8369       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8370       return RFAILED;
8371    }
8372
8373    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8374    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8375    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8376    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8377    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8378    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8379
8380    /* Reference Signal Type */
8381    eventTriggCfg->rsType = NR_RS_Type_ssb;
8382
8383    /* Report Interval */
8384    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8385
8386    /* Report Amount */
8387    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8388
8389    /* Report Quantity cell */
8390    eventTriggCfg->reportQuantityCell.rsrp = true;
8391    eventTriggCfg->reportQuantityCell.rsrq = false;
8392    eventTriggCfg->reportQuantityCell.sinr = false;
8393
8394    /* Maximum reported cells */
8395    eventTriggCfg->maxReportCells = 3;
8396
8397    /* Report qunatity RS Indexes */
8398    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8399    if(!eventTriggCfg->reportQuantityRS_Indexes)
8400    {
8401       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8402       return RFAILED;
8403    }
8404    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8405    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8406    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8407
8408    /* Maximum number of RS indexes to report */
8409    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8410    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8411    {
8412       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8413       return RFAILED;
8414    }
8415    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8416
8417    /* Include Beam measurement */
8418    eventTriggCfg->includeBeamMeasurements = false;
8419
8420    return ROK;
8421 }
8422
8423 /*******************************************************************
8424  *
8425  * @brief Fill measurement Id to add/mod list
8426
8427  * @details
8428  *
8429  *    Function : fillMeasIdToAddModList
8430  *
8431  *    Functionality: Fill measurement Id to add/mod list
8432  *
8433  * @params[in] Measurement Id to add/mod list
8434  * @return ROK     - success
8435  *         RFAILED - failure
8436  *
8437  * ****************************************************************/
8438 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8439 {
8440    uint8_t elementCnt;
8441    uint8_t measIdIdx;
8442
8443    elementCnt = 1;
8444    measIdList->list.count = elementCnt;
8445    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8446
8447    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8448    if(!measIdList->list.array)
8449    {
8450       return RFAILED;
8451    }
8452
8453    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8454    {
8455       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8456       if(!measIdList->list.array[measIdIdx])
8457       {
8458          return RFAILED;
8459       }
8460
8461       measIdIdx=0;
8462       measIdList->list.array[measIdIdx]->measId = 1;
8463       measIdList->list.array[measIdIdx]->measObjectId = 1;
8464       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8465    }
8466    return ROK;
8467 }
8468
8469 /*******************************************************************
8470  *
8471  * @brief Fill s-measurement configuration
8472  *
8473  * @details
8474  *
8475  *    Function : fillSMeasConfig
8476  *
8477  *    Functionality: Fill s-measurement configuration
8478  *
8479  * @params[in] s-Measurement config
8480  * @return ROK     - success
8481  *         RFAILED - failure
8482  *
8483  * ****************************************************************/
8484 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8485 {
8486    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8487    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8488
8489    return ROK;
8490 }
8491
8492 /*******************************************************************
8493  *
8494  * @brief Fill quantity config
8495  *
8496  * @details
8497  *
8498  *    Function : fillQunatityConfig
8499  *
8500  *    Functionality: Fill quantity config
8501  *
8502  * @params[in] Quantity Config
8503  * @return ROK     - success
8504  *         RFAILED - failure
8505  *
8506  * ****************************************************************/
8507 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8508 {
8509    uint8_t elementCnt = 0;
8510    uint8_t quanCfgIdx = 0;
8511    QuantityConfigNR_t *quantityCfgNr;
8512
8513    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8514    if(!quantityCfg->quantityConfigNR_List)
8515    {
8516       return RFAILED;
8517    }
8518
8519    elementCnt = 1;
8520    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8521    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8522
8523    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8524    if(!quantityCfg->quantityConfigNR_List->list.array)
8525    {
8526       return RFAILED;
8527    }
8528
8529    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8530    {
8531       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8532       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8533       {
8534          return RFAILED;
8535       }
8536    }
8537
8538    quanCfgIdx = 0;
8539    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8540
8541    /* Quantity Config of Reference signal */
8542    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8543    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8544    {
8545       return RFAILED;
8546    }
8547    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8548
8549    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8550    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8551    {
8552       return RFAILED;
8553    }
8554    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8555
8556    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8557    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8558    {
8559       return RFAILED;
8560    }
8561    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8562
8563    /* Quantity Config RS index */
8564    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8565    if(!quantityCfgNr->quantityConfigRS_Index)
8566    {
8567       return RFAILED;
8568    }
8569
8570    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8571    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8572    {
8573       return RFAILED;
8574    }
8575    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8576
8577    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8578    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8579    {
8580       return RFAILED;
8581    }
8582    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8583
8584    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8585    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8586    {
8587       return RFAILED;
8588    }
8589    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8590
8591    return ROK;
8592 }
8593
8594 /*******************************************************************
8595  *
8596  * @brief Fill measurement configuration
8597  *
8598  * @details
8599  *
8600  *    Function : fillMeasConfig
8601  *
8602  *    Functionality: Fill measurement configuration
8603  *
8604  * @params[in] Measurement config
8605  * @return ROK     - success
8606  *         RFAILED - failure
8607  *
8608  * ****************************************************************/
8609 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8610 {
8611    /* Measurement object to add/mod list */
8612    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8613    if(!measConfig->measObjectToAddModList)
8614    {
8615       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8616       return RFAILED;
8617    }
8618    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8619    {
8620       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8621       return RFAILED;
8622    }
8623
8624    /* Report Config To add/mod list */
8625    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8626    if(!measConfig->reportConfigToAddModList)
8627    {
8628       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8629       return RFAILED;
8630    }
8631    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8632    {
8633       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8634       return RFAILED;
8635    }
8636
8637    /* Measurement Id to add/mod list */
8638    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8639    if(!measConfig->measIdToAddModList)
8640    {
8641       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8642       return RFAILED;
8643    }
8644    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8645    {
8646       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8647       return RFAILED;
8648    }
8649
8650    /* S-Measurement config */
8651    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8652    if(!measConfig->s_MeasureConfig)
8653    {
8654       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8655       return RFAILED;
8656    }
8657    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8658    {
8659       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8660       return RFAILED;
8661    }
8662
8663    /* Qunatity Config */
8664    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8665    if(!measConfig->quantityConfig)
8666    {
8667       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8668       return RFAILED;
8669    }
8670    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8671    {
8672       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8673       return RFAILED;
8674    }
8675
8676 return ROK;
8677 }
8678
8679 /*******************************************************************
8680  *
8681  * @brief Fill RRC reconfiguration non-critical extension IE
8682  *
8683  * @details
8684  *
8685  *    Function : fillRrcReconfigNonCriticalExt
8686  *
8687  *    Functionality: Fill RRC reconfiguration non-critical extension
8688  *
8689  * @params[in] RRC Reconfig Non-critical extension
8690  * @return ROK     - success
8691  *         RFAILED - failure
8692  *
8693  * ****************************************************************/
8694 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8695 {
8696    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8697    if(!rrcRecfg->masterCellGroup)
8698    {
8699       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8700       return RFAILED;
8701    }
8702
8703    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8704    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8705    if(!rrcRecfg->masterCellGroup->buf)
8706    {
8707       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8708       return RFAILED;
8709    }
8710    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8711
8712 #if 0
8713    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8714     * received from DU */
8715    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8716    {
8717       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8718       return RFAILED;
8719    }
8720 #endif
8721
8722    return ROK;
8723 }
8724
8725 /*******************************************************************
8726  *
8727  * @brief Fill RRC reconfiguration structure
8728  *
8729  * @details
8730  *
8731  *    Function : fillRrcReconfig
8732  *
8733  *    Functionality: Fill RRC reconfiguration
8734
8735  *
8736  * @params[in] UE Cb
8737  *             RRC reconfiguration structure
8738  * @return ROK     - success
8739  *         RFAILED - failure
8740  *
8741  * ****************************************************************/
8742 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8743 {
8744    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8745
8746    rrcReconfig->rrc_TransactionIdentifier = 1;
8747    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8748
8749    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8750    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8751    {
8752       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8753       return RFAILED;
8754    }
8755
8756    /* Radio Bearer Configuration */
8757    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8758    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8759    {
8760       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8761       return RFAILED;
8762    }
8763    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8764    {
8765       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8766       return RFAILED;
8767    }
8768
8769    /* Measurement Configuration */
8770    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8771    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8772    {
8773       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8774       return RFAILED;
8775    }
8776    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8777    {
8778       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8779       return RFAILED;
8780    }
8781
8782    /* Non Critical extension */
8783    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8784    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8785    {
8786       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8787       return RFAILED;
8788    }
8789    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8790    {
8791       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8792       return RFAILED;
8793    }
8794    return ROK;
8795 }
8796
8797 /*******************************************************************
8798  *
8799  * @brief Fill RRC reconfiguration Octet string
8800  *
8801  * @details
8802  *
8803  *    Function : fillRrcReconfigBuf
8804  *
8805  *    Functionality: Fill RRC reconfiguration octet string
8806
8807  *
8808  * @params[in] OCTET_STRING_t buffer
8809  * @return ROK     - success
8810  *         RFAILED - failure
8811  *
8812  * ****************************************************************/
8813 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8814 {
8815    uint8_t          ret = RFAILED;
8816    asn_enc_rval_t   encRetVal;
8817    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8818    rrcReconfig = &rrcRecfg;
8819
8820    while(true)
8821    {
8822       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8823       {
8824          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8825          break;
8826       }
8827
8828       /* Encode RRC Reconfiguration */
8829       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8830       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8831       encBufSize = 0;
8832       encRetVal = uper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8833
8834       /* Encode results */
8835       if(encRetVal.encoded == ENCODE_FAIL)
8836       {
8837          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8838                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8839          break;
8840       }
8841       else
8842       {
8843          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8844          for(int i=0; i< encBufSize; i++)
8845          {
8846             DU_LOG("%x",encBuf[i]);
8847          }
8848       }
8849
8850       rrcReconfigBuf->size = encBufSize;
8851       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8852       if(!rrcReconfigBuf->buf)
8853       {
8854          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8855          break;
8856       }
8857       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8858       ret = ROK;
8859       break;
8860    }
8861
8862    freeRrcReconfig(rrcReconfig);
8863    return ret;
8864 }
8865
8866 /*******************************************************************
8867  *
8868  * @brief Fill HO preparation information Octet string
8869  *
8870  * @details
8871  *
8872  *    Function : fillHOPreparationInfoBuf
8873  *
8874  *    Functionality: Fill HO preparation information Octet string
8875
8876  *
8877  * @params[in] HandoverPreparationInformation_t buffer
8878  * @return ROK     - success
8879  *         RFAILED - failure
8880  *
8881  * ****************************************************************/
8882 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8883 {
8884    uint8_t          ret = RFAILED;
8885    asn_enc_rval_t   encRetVal;
8886    HandoverPreparationInformationRrc_t hoPrepInfo;
8887    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8888
8889    while(true)
8890    {
8891
8892       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8893       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8894       if(!hoPrepInfo.criticalExtensions.choice.c1)
8895       {
8896          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8897          break;
8898       }
8899       hoPrepInfo.criticalExtensions.choice.c1->present = \
8900          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8901
8902       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8903          sizeof(HandoverPreparationInformationRrc_IEs_t));
8904       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8905       {
8906          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8907          break;
8908       }
8909       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8910
8911       /* Fill UE Capability RAT container list */
8912       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8913       if(ret != ROK)
8914       {
8915          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8916          break;
8917       }
8918
8919       /* Fill Source config */
8920       hoPrepInfoIe->sourceConfig = NULLP;
8921       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8922       if(!hoPrepInfoIe->sourceConfig)
8923       {
8924          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8925          return RFAILED;
8926       }
8927       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8928
8929       if(ret != ROK)
8930       {
8931          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8932          return RFAILED;
8933       }
8934
8935       hoPrepInfoIe->rrm_Config = NULLP;
8936       hoPrepInfoIe->as_Context = NULLP;
8937       hoPrepInfoIe->nonCriticalExtension = NULLP;
8938
8939       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8940       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8941       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8942       encBufSize = 0;
8943       encRetVal = uper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8944             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8945
8946       /* Encode results */
8947       if(encRetVal.encoded == ENCODE_FAIL)
8948       {
8949          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8950                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8951          break;
8952       }
8953       else
8954       {
8955          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8956          for(int i=0; i< encBufSize; i++)
8957          {
8958             DU_LOG("%x",encBuf[i]);
8959          }
8960       }
8961
8962       hoPrepInfoBuf->size = encBufSize;
8963       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8964       if(!hoPrepInfoBuf->buf)
8965       {
8966          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8967          break;
8968       }
8969       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8970       ret = ROK;
8971       break;
8972    }
8973    freeHOPreparationInfo(&hoPrepInfo);
8974    return ret;
8975 }
8976
8977 /*******************************************************************
8978  *
8979  * @brief Fills CuToDuContainer
8980  *
8981  * @details
8982  *
8983  *    Function : fillCuToDuContainer
8984  *
8985  *    Functionality: Fills CuToDuContainer
8986  *
8987  * @params[in] pointer to CUtoDURRCInformation_t
8988  *
8989  * @return ROK     - success
8990  *         RFAILED - failure
8991  *
8992  ******************************************************************/
8993
8994 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8995 {
8996    uint8_t elementCnt = 0;
8997    uint8_t ret = ROK;
8998    uint8_t idx;
8999
9000    /* UE Capabulity RAT Container List */
9001    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9002    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
9003    {
9004       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
9005       return RFAILED;
9006    }
9007    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
9008
9009 #if 0
9010
9011    /* Commenting this because:
9012     * CUToDURRCInformation->MeasConfig contains measurement gap configurations.
9013     * Howeever measurement gap is not supported in our code. Measurement Gap will
9014     * be required if we want to support inter-RAT handover or handover to
9015     * neighbouring cells operating on a different frequency than serving cell.
9016     *
9017     * In case we plan to use this IE in future, following fixes are required:
9018     * As of now, we are filling MeasurementTimingConfigurationRrc_t into rrcMsg->measConfig.
9019     * This is incorrect. We must fill MeasConfigRrc_t in rrcMsg->measConfig.
9020     * MeasurementTimingConfigurationRrc_t should be filled in
9021     * rrcMsg->iE_Extensions->MeasurementTimingConfiguration, if required.
9022     */
9023
9024    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
9025    if(!rrcMsg->measConfig)
9026    {
9027       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
9028       return RFAILED;
9029    }
9030    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
9031 #endif
9032
9033    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9034    {
9035       /* IE extensions */
9036       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9037       if(rrcMsg->iE_Extensions)
9038       {
9039          elementCnt = 1;
9040          rrcMsg->iE_Extensions->list.count = elementCnt;
9041          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
9042
9043          /* Initialize the CUtoDURRCInformation_ExtIEs */
9044          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9045
9046          if(rrcMsg->iE_Extensions->list.array == NULLP)
9047          {
9048             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
9049             ret = RFAILED;
9050          }
9051
9052          for(idx=0; idx<elementCnt; idx++)
9053          {
9054             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
9055             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
9056             {
9057                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
9058                ret = RFAILED;
9059             }
9060          }
9061
9062          idx = 0;
9063 #if 0
9064          /* Cell Group Configuration */
9065          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
9066          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9067          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
9068                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
9069          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
9070          idx++;
9071 #endif
9072          /* Handover Preparation Information */
9073          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
9074          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9075          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
9076                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
9077          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
9078       }
9079    }
9080    return ret;
9081 }
9082 /*******************************************************************
9083  *
9084  * @brief Build the drx cycle
9085  *
9086  * @details
9087  *
9088  *    Function : BuildDrxCycle
9089  *
9090  *    Functionality: Build drx cycle IE
9091  *
9092  * @params[in] pointer to DRXCycle_t
9093  *
9094  * @return ROK     - success
9095  *         RFAILED - failure
9096  *
9097  ******************************************************************/
9098 uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
9099 {
9100    drxCycle->longDRXCycleLength = LongDRXCycleLength_ms80;
9101    CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
9102    if(!drxCycle->shortDRXCycleLength)
9103    {
9104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleLength");
9105       return RFAILED;
9106    }
9107    *(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
9108
9109    CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
9110    if(!drxCycle->shortDRXCycleTimer)
9111    {
9112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleTimer");
9113       return RFAILED;
9114    }
9115    *(drxCycle->shortDRXCycleTimer) = 4;
9116    return ROK;
9117 }
9118 /*******************************************************************
9119  *
9120  * @brief Free CuToDuContainer
9121  *
9122  * @details
9123  *
9124  *    Function : FreeCuToDuInfo
9125  *
9126  *    Functionality: Free CuToDuContainer
9127  *
9128  * @params[in] pointer to CUtoDURRCInformation_t
9129  *
9130  * @return ROK     - success
9131  *         RFAILED - failure
9132  *
9133  ******************************************************************/
9134
9135 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9136 {
9137    uint8_t idx, idx2;
9138
9139    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9140    {
9141       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9142          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
9143       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9144    }
9145    if(rrcMsg->iE_Extensions)
9146    {
9147       if(rrcMsg->iE_Extensions->list.array)
9148       {
9149          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
9150          {
9151             if(rrcMsg->iE_Extensions->list.array[idx])
9152             {
9153                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
9154                {
9155                   case ProtocolIE_ID_id_CellGroupConfig:
9156                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9157                      {
9158                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
9159                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
9160
9161                      }
9162                      break;
9163                   default:
9164                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9165                            rrcMsg->iE_Extensions->list.array[idx]->id);
9166                      break;
9167                }
9168             }
9169             break;
9170          }
9171          for(idx2 = 0; idx2 < idx; idx2++)
9172          {
9173             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
9174          }
9175          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9176
9177       }
9178
9179       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9180    }
9181 }
9182 /*******************************************************************
9183  *
9184  * @brief Builds and sends the UE Setup Request
9185  *
9186  * @details
9187  *
9188  *    Function : BuildAndSendUeContextSetupReq
9189  *
9190  *    Functionality: Constructs the UE Setup Request and sends
9191  *                   it to the CU through SCTP.
9192  *
9193  * @params[in]
9194  *
9195  * @return ROK     - success
9196  *         RFAILED - failure
9197  *
9198  * ****************************************************************/
9199 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
9200 {
9201    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
9202    uint8_t   ret= RFAILED, ret1;
9203    uint8_t   elementCnt;
9204    uint8_t   idx, idx1, bufLen, duIdx;
9205    uint32_t  spCellId;
9206    DuDb      *targetDuDb = NULLP;
9207    F1AP_PDU_t           *f1apMsg = NULLP;
9208    UEContextSetupRequest_t *ueSetReq = NULLP;
9209    asn_enc_rval_t encRetVal;        /* Encoder return value */
9210    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9211
9212    while(true)
9213    {
9214       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
9215
9216       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9217       if(f1apMsg == NULLP)
9218       {
9219          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9220          break;
9221       }
9222
9223       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9224       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9225       if(f1apMsg->choice.initiatingMessage == NULLP)
9226       {
9227          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
9228          break;
9229       }
9230
9231       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
9232       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9233       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
9234
9235       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9236
9237       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9238          elementCnt = 7;
9239       else
9240       {
9241 #ifdef NR_DRX
9242          elementCnt = 12;
9243 #else
9244          elementCnt = 11;
9245 #endif
9246       }
9247       ueSetReq->protocolIEs.list.count = elementCnt;
9248       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
9249
9250       /* Initialize the UESetup members */
9251       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
9252
9253       if(ueSetReq->protocolIEs.list.array == NULLP)
9254       {
9255          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
9256          break;
9257       }
9258
9259       for(idx1=0; idx1<elementCnt; idx1++)
9260       {
9261          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
9262          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
9263          {
9264             break;
9265          }
9266       }
9267
9268       idx = 0;
9269
9270       /*GNB CU UE F1AP ID*/
9271       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9272       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9273       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
9274       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
9275
9276       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9277       {
9278          /*GNB DU UE F1AP ID*/
9279          idx++;
9280          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9281          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9282          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
9283          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
9284       }
9285
9286       /*Special Cell ID*/
9287       idx++;
9288       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
9289       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9290       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
9291       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9292       {
9293          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
9294          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
9295          /* Since we are supporting only one cell per DU, accessing 0th index to
9296           * get target cell info */
9297          spCellId = targetDuDb->cellCb[0].nrCellId;
9298       }
9299       else
9300          spCellId = ueCb->cellCb->nrCellId;
9301       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
9302       if(Nrcgiret != ROK)
9303       {
9304          break;
9305       }
9306
9307       /*Served Cell Index*/
9308       idx++;
9309       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9310       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9311       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9312       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9313
9314       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9315       {
9316          /*CellULConfigured*/
9317          idx++;
9318          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9319          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9320          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9321          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9322       }
9323
9324       /*CUtoDURRCContainer*/
9325       idx++;
9326       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9327       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9328       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9329       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9330       {
9331          break;
9332       }
9333
9334       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9335       {
9336          /*Drx cycle*/
9337 #ifdef NR_DRX
9338          idx++;
9339          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_DRXCycle;
9340          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9341          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
9342          if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
9343          {
9344             DU_LOG("\nERROR  -->  F1AP : Failed to build drx cycle");
9345             break;
9346          }
9347 #endif
9348          /*Special Cells to be SetupList*/
9349          idx++;
9350          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9351          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9352          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9353          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9354          if(SplCellListret != ROK)
9355          {
9356             break;
9357          }
9358       }
9359
9360       /*SRBs To Be Setup List*/
9361       idx++;
9362       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9363       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9364       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9365       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9366       if(SrbSetupret != ROK)
9367       {
9368          break;
9369       }
9370
9371       /*DRBs to Be Setup List*/
9372       idx++;
9373       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9374       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9375       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9376       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9377       if(ret1 != ROK)
9378       {
9379          break;
9380       }
9381
9382       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9383       {
9384          /* RRC delivery status request */
9385          idx++;
9386          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9387          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9388          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9389          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9390       }
9391
9392       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9393       idx++;
9394       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9395       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9396       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9397
9398       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9399       bufLen = 4;
9400       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9401       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9402             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9403       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9404       {
9405          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9406          break;
9407       }
9408       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9409       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9410
9411       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9412
9413       /* Encode the F1SetupRequest type as APER */
9414       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9415       encBufSize = 0;
9416       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9417
9418       /* Encode results */
9419       if(encRetVal.encoded == ENCODE_FAIL)
9420       {
9421          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9422                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9423          break;
9424       }
9425       else
9426       {
9427          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9428          for(int i=0; i< encBufSize; i++)
9429          {
9430             DU_LOG("%x",encBuf[i]);
9431          }
9432       }
9433
9434       /* Sending  msg  */
9435       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9436       {
9437          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9438          break;
9439       }
9440       ret = ROK;
9441       break;
9442    }
9443    FreeUeContextSetupReq(f1apMsg);
9444
9445    return ret;
9446 }/* End of BuildAndSendUeContextSetupReq*/
9447
9448 /**********************************************************************
9449  * @brief Function to extractTeId received in UE context setup Response
9450  *
9451  * @details
9452  *
9453  *    Function : extractTeId
9454  *
9455  *    Functionality:
9456  *         - Function to extract TeId
9457  *
9458  * @params[in]
9459  * @return ROK     - success
9460  *         RFAILED - failure
9461  *
9462  **********************************************************************/
9463 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9464 {
9465    uint8_t arrIdx = 0;
9466    uint32_t teId = 0;
9467    GTPTunnel_t *gtpDl = NULLP;
9468
9469    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9470    {
9471       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9472       {
9473          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9474          {
9475             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9476             if(gtpDl->gTP_TEID.size > 0)
9477             {
9478                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9479             }
9480             else
9481                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9482             return(teId);
9483          }
9484       }
9485    }
9486    return teId;
9487 }
9488
9489 /****************************************************************
9490  * @brief Function to add Drb tunnels
9491  *
9492  * @details
9493  *
9494  *    Function : addDrbTunnels
9495  *
9496  *    Functionality:
9497  *         - Function to add Drb tunnels
9498  *
9499  * @params[in]
9500  * @return ROK     - success
9501  *         RFAILED - failure
9502  *
9503  * ****************************************************************/
9504 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9505 {
9506    uint8_t ret = ROK;
9507    EgtpTnlEvt tnlEvt;
9508
9509    if(teId > MAX_TEID || teId < MIN_TEID)
9510    {
9511       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9512    }
9513    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9514    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9515    tnlEvt.lclTeid = teId;
9516    tnlEvt.remTeid = teId;
9517    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9518    if(ret != ROK)
9519    {
9520       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9521    }
9522    return ROK;
9523 }
9524
9525 /****************************************************************
9526  * @brief Function to process Drb Setup List
9527  *
9528  * @details
9529  *
9530  *    Function : procDrbSetupList
9531  *
9532  *    Functionality:
9533  *         - Function to process DRB Setup List
9534  *
9535  * @params[in]
9536  * @return ROK     - success
9537  *         RFAILED - failure
9538  *
9539  * ****************************************************************/
9540 uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
9541 {
9542    uint8_t arrIdx = 0, drbIdx = 0;
9543    uint32_t teId = 0;
9544    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9545
9546    if(drbSetupList != NULLP)
9547    {
9548       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9549       {
9550          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9551          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9552          {
9553             /* extracting teId */
9554             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9555             if(teId > 0)
9556             {
9557                if(addDrbTunnels(duId, teId)== ROK)
9558                {
9559                   DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9560                }
9561                /* As per Spec 38.473, in UE COntext Response, Tunnel information
9562                 * are sent to CU for setting up of Tunnels in DL direction.
9563                 * Search for DRB ID in CU databse */
9564                for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
9565                {
9566                   if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
9567                   {
9568                      fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
9569                      break;
9570                   }
9571                }
9572             }
9573             else
9574                return RFAILED;
9575          }
9576       }
9577    }
9578    return ROK;
9579 }
9580
9581 /****************************************************************
9582  * @brief Function to process Ue Context Setup Response
9583  *
9584  * @details
9585  *
9586  *    Function : procUeContextSetupResponse
9587  *
9588  *    Functionality:
9589  *         - Function to process Ue Context Setup Response
9590  *
9591  * @params[in]
9592  * @return ROK     - success
9593  *         RFAILED - failure
9594  *
9595  * ****************************************************************/
9596 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9597 {
9598    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9599    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9600    DuDb *duDb = NULLP;
9601    CuUeCb *ueCb = NULLP;
9602    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9603    OCTET_STRING_t *duToCuRrcContainer;
9604
9605    SEARCH_DU_DB(duIdx, duId, duDb);
9606    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9607
9608    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9609    {
9610       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9611       {
9612           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9613              {
9614                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9615                break;
9616              }
9617           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9618              {
9619                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9620                 ueCb = &duDb->ueCb[duUeF1apId-1];
9621                 /* If ue context is not present in du db, then create UE context
9622                  * here. This flow is hit in case of UE handover where UE
9623                  * context is created before UE performs RACH on target DU */
9624                 if(ueCb->gnbDuUeF1apId == 0)
9625                 {
9626                    /* Creating UE context in target DU */
9627                    memset(ueCb, 0, sizeof(CuUeCb));
9628                    ueCb->cellCb = &duDb->cellCb[0];
9629                    ueCb->gnbDuUeF1apId = duUeF1apId;
9630                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9631                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9632                    ueCb->hoInfo.targetDuId = duId;
9633                    (duDb->numUe)++;
9634
9635                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9636                    ueCb->cellCb->numUe++;
9637                 }
9638                 break;
9639              }
9640           case ProtocolIE_ID_id_C_RNTI:
9641              {
9642                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9643                 break;
9644              }
9645           case ProtocolIE_ID_id_DRBs_Setup_List:
9646              {
9647                 /* Adding Tunnels for successful DRB */
9648                 procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9649                 break;
9650              }
9651          case ProtocolIE_ID_id_DUtoCURRCInformation:
9652              {
9653                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9654                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9655                    DUtoCURRCInformation.cellGroupConfig;
9656                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9657                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9658                 {
9659                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9660                    return RFAILED;
9661                 }
9662                 break;
9663              }
9664       }
9665    }
9666
9667    /* If the UE is in handover, UE context modification request is to be sent to
9668     * source DU once UE context setup response is received from target DU */
9669    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9670    {
9671       DuDb *srcDuDb = NULLP;
9672       CuUeCb *ueCbInSrcDu = NULLP;
9673
9674       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9675        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9676       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9677       {
9678          /* UE context setup response is received from target DU. Search all
9679           * DUs to find source DU except this target DU Id.*/
9680          if(cuCb.duInfo[duIdx].duId != duId)
9681          {
9682             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9683             {
9684                /* Check following:
9685                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9686                 * received in UE context setup response since CU UE F1AP ID does not
9687                 * change for UE in handover.
9688                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9689                 */
9690                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9691                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9692                {
9693                   srcDuDb = &cuCb.duInfo[duIdx];
9694                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9695
9696                   /* Store source DU info in the new UE context created in
9697                    * tareget DU */
9698                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9699
9700                   /* Copy the received container to UeCb */
9701                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9702
9703                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9704                   {
9705                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9706                      return RFAILED;
9707                   }
9708                   break;
9709                }
9710             }
9711          }
9712          if(srcDuDb && ueCbInSrcDu)
9713             break;
9714       }
9715    }
9716    else
9717    {
9718       ueCb->f1apMsgDb.dlRrcMsgCount++;
9719       rrcMsgType = setDlRRCMsgType(ueCb);
9720
9721       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9722       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9723       {
9724          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9725          return RFAILED;
9726       }
9727    }
9728
9729    return ROK;
9730 }
9731
9732 /****************************************************************
9733  * @brief Function to process Ul Rrc Msg received from DU
9734  *
9735  * @details
9736  *
9737  *    Function : procUlRrcMsg
9738  *
9739  *    Functionality:
9740  *         - Function to process Ul Rrc Msg received from DU
9741  *
9742  * @params[in]
9743  * @return ROK     - success
9744  *         RFAILED - failure
9745  *
9746  * ****************************************************************/
9747
9748 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9749 {
9750    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9751    uint8_t  *rrcContainer = NULLP;
9752    uint16_t rrcContLen = 0;
9753    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9754    DuDb     *duDb = NULLP;
9755    CuUeCb   *ueCb = NULLP;
9756    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9757
9758    ret = ROK;
9759    SEARCH_DU_DB(duIdx, duId, duDb);
9760    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9761
9762    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9763    {
9764       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9765       {
9766          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9767             {
9768                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9769                break;
9770             }
9771          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9772             {
9773                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9774                break;
9775             }
9776          case ProtocolIE_ID_id_SRBID:
9777             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9778             break;
9779
9780          case ProtocolIE_ID_id_RRCContainer:
9781             {
9782                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9783                CU_ALLOC(rrcContainer, rrcContLen);
9784                if(!rrcContainer)
9785                {
9786                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9787                   return RFAILED;
9788                }
9789                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9790
9791                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9792                {
9793                   uint8_t ueIdx = 0;
9794                   uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.sourceDuId;
9795                   DuDb *srcDuDb = NULLP;
9796
9797                   /* In target DU DB, mark UE as active and delete HO info */
9798                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9799                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9800
9801                   /* Release UE context in source DU because the UE is now
9802                    * attached to target DU */
9803                   SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9804                   for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9805                   {
9806                      if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9807                      {
9808                         ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9809                         if(ret != ROK)
9810                         {
9811                            DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9812                         }
9813                         break;
9814                      }
9815                   }
9816                   return ret;
9817                }
9818                break;
9819             }
9820
9821          default:
9822             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9823             break;
9824       }
9825    }
9826
9827    if(srbId == 1)
9828    {
9829       ueCb = &duDb->ueCb[duUeF1apId-1];
9830       ueCb->f1apMsgDb.dlRrcMsgCount++;
9831       rrcMsgType = setDlRRCMsgType(ueCb);
9832       if(rrcMsgType == RRC_SETUP_COMPLETE)
9833       {
9834          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for NAS Security Mode Command");
9835          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9836       }
9837       if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
9838       {
9839          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Security Mode Command");
9840          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9841       }
9842       else if(rrcMsgType == RRC_SECURITY_MODE_COMPLETE)
9843       {
9844          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9845          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9846       }
9847       else if(rrcMsgType == REGISTRATION_COMPLETE)
9848       {
9849          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9850          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9851       }
9852       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9853       {
9854          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9855          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9856       }
9857    }
9858    return ret;
9859 }
9860
9861 /****************************************************************
9862  * @brief Build And Send F1ResetAck
9863  *
9864  * @details
9865  *
9866  *    Function : FreeF1ResetAck
9867  *
9868  *    Functionality:
9869  *         - Build And Send  F1ResetRSP
9870  *
9871  *  @params[in]
9872  * @return ROK     - success
9873  *         RFAILED - failure
9874  *
9875  * ****************************************************************/
9876 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9877 {
9878    uint8_t idx;
9879    ResetAcknowledge_t *f1ResetAck;
9880
9881    if(f1apMsg)
9882    {
9883       if(f1apMsg->choice.successfulOutcome)
9884       {
9885          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9886
9887          if(f1ResetAck->protocolIEs.list.array)
9888          {
9889             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9890             {
9891                if(f1ResetAck->protocolIEs.list.array[idx])
9892                {
9893                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9894                }
9895             }
9896             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9897          }
9898          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9899       }
9900       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9901    }
9902 }
9903
9904 /****************************************************************
9905  * @brief Build And Send F1ResetAck
9906  *
9907  * @details
9908  *
9909  *    Function : BuildAndSendF1ResetAck
9910  *
9911  *    Functionality:
9912  *         - Build And Send  F1ResetRSP
9913  *
9914  *  @params[in]
9915  * @return ROK     - success
9916  *         RFAILED - failure
9917  *
9918  * ****************************************************************/
9919
9920 uint8_t BuildAndSendF1ResetAck()
9921 {
9922    uint8_t                idx = 0;
9923    uint8_t                elementCnt = 0;
9924    uint8_t                ret = RFAILED;
9925    F1AP_PDU_t             *f1apMsg = NULL;
9926    ResetAcknowledge_t     *f1ResetAck = NULLP;
9927    asn_enc_rval_t         encRetVal;
9928    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9929
9930    do{
9931       /* Allocate the memory for F1ResetRequest_t */
9932       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9933       if(f1apMsg == NULLP)
9934       {
9935          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9936          break;
9937       }
9938
9939       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9940
9941       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9942       if(f1apMsg->choice.successfulOutcome == NULLP)
9943       {
9944          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9945          break;
9946       }
9947
9948       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9949       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9950       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9951       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9952
9953       elementCnt = 1;
9954
9955       f1ResetAck->protocolIEs.list.count = elementCnt;
9956       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9957
9958       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9959       if(f1ResetAck->protocolIEs.list.array == NULLP)
9960       {
9961          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9962          break;
9963       }
9964
9965       for(idx=0; idx<elementCnt; idx++)
9966       {
9967          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9968          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9969          {
9970             break;
9971          }
9972       }
9973       /*TransactionID*/
9974       idx = 0;
9975       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9976       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9977       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9978       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9979
9980       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9981
9982       /* Encode the F1SetupRequest type as UPER */
9983       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9984       encBufSize = 0;
9985       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9986
9987       /* Check encode results */
9988       if(encRetVal.encoded == ENCODE_FAIL)
9989       {
9990          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9991                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9992          break;
9993       }
9994       else
9995       {
9996          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9997          for(int i=0; i< encBufSize; i++)
9998          {
9999             DU_LOG("%x",encBuf[i]);
10000          }
10001       }
10002
10003       /* Sending msg */
10004       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10005       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
10006       {
10007          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
10008          break;
10009       }
10010
10011       ret = ROK;
10012       break;
10013    }while(true);
10014
10015    FreeF1ResetAck(f1apMsg);
10016    return ret;
10017 }
10018
10019 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10020 {
10021    uint8_t arrIdx =0;
10022
10023    if(ulInfo->list.array)
10024    {
10025       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
10026       {
10027          if(ulInfo->list.array[arrIdx])
10028          {
10029             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
10030             {
10031                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
10032                {
10033                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
10034                   {
10035                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10036                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10037                      gTPTunnel->gTP_TEID.size);
10038                   }
10039                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10040                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10041                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10042                }
10043                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10044                sizeof(GTPTunnel_t));
10045             }
10046             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10047          }
10048       }
10049       CU_FREE(ulInfo->list.array,ulInfo->list.size);
10050    }
10051 }
10052
10053 /*******************************************************************
10054 *
10055 * @brief Deletes the EGTP tunnel
10056 *
10057 * @details
10058 *
10059 *    Function : deleteEgtpTunnel
10060 *
10061 *    Functionality: Deletes the EGTP tunnel
10062 *
10063 * @params[in] uint8_t *buf
10064 *
10065 * @return ROK     - success
10066 *         RFAILED - failure
10067 *
10068 * ****************************************************************/
10069 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
10070 {
10071    uint32_t teId = 0;
10072    EgtpTnlEvt tnlEvt;
10073
10074    teIdStringToInt(buf, &teId);
10075    if(teId > MAX_TEID || teId < MIN_TEID)
10076    {
10077       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
10078       return RFAILED;
10079    }
10080    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
10081    tnlEvt.action = EGTP_TNL_MGMT_DEL;
10082    tnlEvt.lclTeid = teId;
10083    tnlEvt.remTeid = teId;
10084    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
10085    {
10086       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
10087    }
10088    return ROK;
10089 }
10090
10091 /*******************************************************************
10092 *
10093 * @brief Builds the Uplink Tunnel Info
10094 *
10095 * @details
10096 *
10097 *    Function : BuildUlTnlInfoforSetupMod
10098 *
10099 *    Functionality: Constructs the UL TnlInfo For DRB list
10100 *
10101 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10102 *
10103 * @return ROK     - success
10104 *         RFAILED - failure
10105 *
10106 * ****************************************************************/
10107 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
10108 {
10109    uint8_t arrIdx;
10110    uint8_t ulCnt;
10111
10112    ulCnt = 1;
10113    ulInfo->list.count = ulCnt;
10114    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
10115    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
10116    if(ulInfo->list.array == NULLP)
10117    {
10118       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10119       return RFAILED;
10120    }
10121    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
10122    {
10123       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10124       if(ulInfo->list.array[arrIdx] == NULLP)
10125       {
10126          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10127          return RFAILED;
10128       }
10129    }
10130
10131    arrIdx = 0;
10132    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
10133    UPTransportLayerInformation_PR_gTPTunnel;
10134
10135    /*GTP TUNNEL*/
10136    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10137          sizeof(GTPTunnel_t));
10138    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
10139    {
10140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10141       return RFAILED;
10142    }
10143    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10144       transportLayerAddress.size        = 4*sizeof(uint8_t);
10145    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10146          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10147          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10148    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10149          transportLayerAddress.buf == NULLP)
10150    {
10151       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10152       return RFAILED;
10153    }
10154
10155    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10156       transportLayerAddress.buf[0] = 192;
10157    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10158       transportLayerAddress.buf[1] = 168;
10159    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10160       transportLayerAddress.buf[2] = 130;
10161    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10162       transportLayerAddress.buf[3] = 82;
10163    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10164       transportLayerAddress.bits_unused = 0;
10165
10166    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
10167    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
10168    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
10169    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
10170
10171    /*GTP TEID*/
10172    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
10173       = 4 * sizeof(uint8_t);
10174    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10175          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10176          gTPTunnel->gTP_TEID.size);
10177    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10178          == NULLP)
10179    {
10180       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10181       return RFAILED;
10182    }
10183    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10184       gTP_TEID.buf[0] = 0;
10185    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10186       gTP_TEID.buf[1] = 0;
10187    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10188       gTP_TEID.buf[2] = 0;
10189    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
10190    {
10191      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
10192       * fetched based on the Drb Id */
10193
10194      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
10195       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
10196                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
10197    }
10198    else
10199    {
10200       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10201         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
10202    }
10203
10204    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
10205    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
10206    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
10207    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
10208    return ROK;
10209 }/*End of BuildULTnlInfo*/
10210
10211 /*******************************************************************
10212 *
10213 * @brief freeing the DRB item
10214 *
10215 * @details
10216 *
10217 *    Function : FreeDrbItem
10218 *
10219 *    Functionality: freeing the DRB item
10220 *
10221 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10222 *
10223 * @return ROK     - success
10224 *         RFAILED - failure
10225 *
10226 * ****************************************************************/
10227
10228 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
10229 {
10230    uint8_t arrIdx =0;
10231    SNSSAI_t *snssai =NULLP;
10232    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10233
10234    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10235    switch(drbItem->qoSInformation.present)
10236    {
10237       case QoSInformation_PR_NOTHING:
10238          break;
10239       case QoSInformation_PR_eUTRANQoS:
10240          {
10241             if(drbItem->qoSInformation.choice.eUTRANQoS)
10242             {
10243                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10244             }
10245             break;
10246          }
10247       case QoSInformation_PR_choice_extension:
10248          {
10249             if(drbItem->qoSInformation.choice.choice_extension)
10250             {
10251                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10252
10253                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10254                if(snssai->sST.buf)
10255                {
10256                   CU_FREE(snssai->sST.buf,snssai->sST.size);
10257                }
10258                if(snssai->sD)
10259                {
10260                   if(snssai->sD->buf)
10261                   {
10262                      CU_FREE(snssai->sD->buf,snssai->sD->size);
10263                   }
10264                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10265                }
10266
10267                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10268                if(flowMap->list.array)
10269                {
10270                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10271                   {
10272                      if(flowMap->list.array[arrIdx] )
10273                      {
10274                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10275                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10276                      }
10277                   }
10278                   CU_FREE(flowMap->list.array,flowMap->list.size);
10279                }
10280
10281                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10282             }
10283             break;
10284          }
10285
10286    }
10287    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10288    if(drbItem->uLConfiguration)
10289    {
10290       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10291    }
10292 }
10293
10294 /*******************************************************************
10295 *
10296 * @brief filling the DRB setup Mod item
10297 *
10298 * @details
10299 *
10300 *    Function : FillDrbItemToSetupMod
10301 *
10302 *    Functionality: filling the DRB setup Mod item
10303 *
10304 *
10305 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10306 *
10307 * @return ROK     - success
10308 *         RFAILED - failure
10309 *
10310 * ****************************************************************/
10311
10312 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
10313 {
10314    uint8_t ret = ROK;
10315
10316    /*Drb Id */
10317    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
10318    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
10319
10320    /*qoSInformation*/
10321    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10322
10323    switch(drbItem->qoSInformation.present)
10324    {
10325       case QoSInformation_PR_NOTHING:
10326       {
10327          break;
10328       }
10329       case QoSInformation_PR_eUTRANQoS:
10330       {
10331
10332          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10333          if(drbItem->qoSInformation.choice.eUTRANQoS)
10334          {
10335             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10336             return RFAILED;
10337          }
10338          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10339          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10340             PriorityLevel_no_priority;
10341
10342          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10343             Pre_emptionCapability_may_trigger_pre_emption;
10344
10345          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10346             Pre_emptionVulnerability_pre_emptable;
10347
10348          break;
10349       }
10350       case QoSInformation_PR_choice_extension:
10351       {
10352          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10353          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10354          {
10355             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10356             return RFAILED;
10357          }
10358
10359          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10360          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10361          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10362          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10363            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10364          if(ret != ROK)
10365          {
10366             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10367             return RFAILED;
10368          }
10369
10370          /*SNSSAI*/
10371          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10372                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10373          if(ret != ROK)
10374          {
10375             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10376             return RFAILED;
10377          }
10378
10379          /*Flows mapped to DRB List*/
10380          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10381                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10382           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10383          if(ret != ROK)
10384          {
10385             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10386             return RFAILED;
10387          }
10388       }
10389    }
10390
10391    /*ULUPTNLInformation To Be Setup List*/
10392    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10393       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10394    if(ret != ROK)
10395    {
10396       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10397       return RFAILED;
10398    }
10399
10400    /*RLCMode*/
10401    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10402    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10403
10404    ueCb->numDrb++;
10405    return ROK;
10406 }
10407
10408 /*******************************************************************
10409 *
10410 * @brief Builds the DRB to be Setup Mod ItemIes
10411 *
10412 * @details
10413 *
10414 *    Function : FillDrbItemList
10415 *
10416 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10417 *
10418 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10419 *
10420 * @return ROK     - success
10421 *         RFAILED - failure
10422 *
10423 * ****************************************************************/
10424
10425 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10426 {
10427    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10428    drbItemIe->criticality = Criticality_reject;
10429    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10430
10431    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10432    {
10433       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10434       return RFAILED;
10435    }
10436    return ROK;
10437 }
10438 /*******************************************************************
10439 *
10440 * @brief free the DRB to be Setup Mod list
10441 *
10442 * @details
10443 *
10444 *    Function : FreeDrbToBeSetupModList
10445 *
10446 *    Functionality: free the DRB to be Setup Mod list
10447 *
10448 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10449 *
10450 * @return ROK     - success
10451 *         RFAILED - failure
10452 *
10453 * ****************************************************************/
10454 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10455 {
10456    uint8_t arrIdx =0;
10457    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10458
10459    if(drbSet->list.array)
10460    {
10461       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10462       {
10463          if(drbSet->list.array[arrIdx] != NULLP)
10464          {
10465             if(arrIdx == 0)
10466             {
10467                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10468                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10469             }
10470             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10471          }
10472       }
10473       CU_FREE(drbSet->list.array, drbSet->list.size);
10474    }
10475
10476 }
10477
10478 /*******************************************************************
10479 *
10480 * @brief Builds the DRB to be Setup Mod list
10481 *
10482 * @details
10483 *
10484 *    Function : BuildDrbToBeSetupList
10485 *
10486 *    Functionality: Constructs the DRB to be Setup Mod list
10487 *
10488 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10489 *
10490 * @return ROK     - success
10491 *         RFAILED - failure
10492 *
10493 * ****************************************************************/
10494
10495 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10496 {
10497    uint8_t ret = ROK;
10498    uint8_t arrIdx =0;
10499    uint8_t drbCnt =0;
10500
10501    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10502    drbSet->list.count = drbCnt;
10503    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10504    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10505    if(drbSet->list.array == NULLP)
10506    {
10507       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10508       return  RFAILED;
10509    }
10510
10511    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10512    {
10513       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10514       if(drbSet->list.array[arrIdx] == NULLP)
10515       {
10516          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10517          return  RFAILED;
10518       }
10519
10520       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10521       if(ret != ROK)
10522       {
10523          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10524       }
10525    }
10526
10527    return ret;
10528 }
10529
10530 /*******************************************************************
10531 *
10532 * @brief Filling the DRB to be modified item
10533 *
10534 * @details
10535 *
10536 *    Function : FillDrbToBeModItem
10537 *
10538 *    Functionality: filling the DRB to be modified item
10539 *
10540 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10541 *
10542 * @return ROK     - success
10543 *         RFAILED - failure
10544 *
10545 * ****************************************************************/
10546
10547 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10548 {
10549    uint8_t ret = ROK;
10550    uint drbIdx=0;
10551    DrbInfo *drbToBeMod;
10552
10553    /*Drb Id */
10554    drbItem->dRBID = DRB2 + arrIdx;
10555
10556    /* Search for DRB ID in CU databse */
10557    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10558    {
10559       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10560       {
10561          drbToBeMod = &ueCb->drbList[drbIdx];
10562          break;
10563       }
10564    }
10565
10566    /*qoSInformation*/
10567    drbItem->qoSInformation = NULLP;
10568    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10569    if(drbItem->qoSInformation != NULLP)
10570    {
10571       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10572
10573       switch(drbItem->qoSInformation->present)
10574       {
10575          case QoSInformation_PR_NOTHING:
10576             {
10577                break;
10578             }
10579          case QoSInformation_PR_eUTRANQoS:
10580             {
10581
10582                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10583                if(drbItem->qoSInformation->choice.eUTRANQoS)
10584                {
10585                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10586                   return RFAILED;
10587                }
10588                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10589                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10590                   PriorityLevel_no_priority;
10591
10592                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10593                   Pre_emptionCapability_may_trigger_pre_emption;
10594
10595                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10596                   Pre_emptionVulnerability_pre_emptable;
10597
10598                break;
10599             }
10600          case QoSInformation_PR_choice_extension:
10601             {
10602                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10603                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10604                {
10605                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10606                   return RFAILED;
10607                }
10608
10609                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10610                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10611                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10612                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10613                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10614                if(ret != ROK)
10615                {
10616                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10617                   return RFAILED;
10618                }
10619
10620                /*SNSSAI*/
10621                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10622                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10623                if(ret != ROK)
10624                {
10625                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10626                   return RFAILED;
10627                }
10628
10629                /*Flows mapped to DRB List*/
10630                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10631                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10632                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10633                if(ret != ROK)
10634                {
10635                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10636                   return RFAILED;
10637                }
10638             }
10639       }
10640    }/* End of QoS */
10641
10642    /*ULUPTNLInformation To Be Setup List*/
10643    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10644             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10645    if(ret != ROK)
10646    {
10647       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10648       return RFAILED;
10649    }
10650    return ROK;
10651 }
10652
10653 /*******************************************************************
10654 *
10655 * @brief Builds the DRB to be modified Item IE
10656 *
10657 * @details
10658 *
10659 *    Function : FillDrbToBeModItemList
10660 *
10661 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10662 *
10663 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10664 *
10665 * @return ROK     - success
10666 *         RFAILED - failure
10667 *
10668 * ****************************************************************/
10669
10670 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10671 {
10672    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10673    drbItemIe->criticality = Criticality_reject;
10674    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10675    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10676    {
10677       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10678       return RFAILED;
10679    }
10680
10681    return ROK;
10682 }
10683
10684 /*******************************************************************
10685 *
10686 * @brief Builds the DRB to be modified list
10687 *
10688 * @details
10689 *
10690 *    Function : BuildDrbToBeModList
10691 *
10692 *    Functionality: Constructs the DRB to be modified list
10693 *
10694 * @params[in] DRBs_ToBeModified_List_t *drbSet
10695 *
10696 * @return ROK     - success
10697 *         RFAILED - failure
10698 *
10699 * ****************************************************************/
10700
10701 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10702 {
10703    uint8_t ret = ROK;
10704    uint8_t arrIdx =0;
10705    uint8_t drbCnt =0;
10706
10707    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10708    drbSet->list.count = drbCnt;
10709    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10710    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10711    if(drbSet->list.array == NULLP)
10712    {
10713       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10714       return  RFAILED;
10715    }
10716    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10717    {
10718       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10719       if(drbSet->list.array[arrIdx] == NULLP)
10720       {
10721          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10722          return  RFAILED;
10723       }
10724
10725       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10726       if(ret != ROK)
10727       {
10728          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10729       }
10730    }
10731
10732    return ret;
10733 }
10734
10735 /*******************************************************************
10736 *
10737 * @brief freeing the DRB  item
10738 *
10739 * @details
10740 *
10741 *    Function : FreeModifiedDrbItem
10742 *
10743 *    Functionality: freeing the DRB 2 item
10744 *
10745 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10746 *
10747 * @return ROK     - success
10748 *         RFAILED - failure
10749 *
10750 * ****************************************************************/
10751
10752 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10753 {
10754    uint8_t arrIdx =0;
10755    SNSSAI_t *snssai =NULLP;
10756    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10757
10758    if(drbItem->qoSInformation != NULLP)
10759    {
10760       switch(drbItem->qoSInformation->present)
10761       {
10762          case QoSInformation_PR_NOTHING:
10763             break;
10764          case QoSInformation_PR_eUTRANQoS:
10765             {
10766                if(drbItem->qoSInformation->choice.eUTRANQoS)
10767                {
10768                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10769                }
10770                break;
10771             }
10772          case QoSInformation_PR_choice_extension:
10773             {
10774                if(drbItem->qoSInformation->choice.choice_extension)
10775                {
10776                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10777
10778                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10779                   if(snssai->sST.buf)
10780                   {
10781                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10782                   }
10783                   if(snssai->sD)
10784                   {
10785                      if(snssai->sD->buf)
10786                      {
10787                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10788                      }
10789                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10790                   }
10791
10792                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10793                   if(flowMap->list.array)
10794                   {
10795                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10796                      {
10797                         if(flowMap->list.array[arrIdx] )
10798                         {
10799                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10800                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10801                         }
10802                      }
10803                      CU_FREE(flowMap->list.array,flowMap->list.size);
10804                   }
10805
10806                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10807                }
10808                break;
10809             }
10810       }
10811    }
10812    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10813    if(drbItem->uLConfiguration)
10814    {
10815       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10816    }
10817 }
10818
10819 /*******************************************************************
10820 *
10821 * @brief free the DRB to be modfified list
10822 *
10823 * @details
10824 *
10825 *    Function : FreeDrbToBeModifiedList
10826 *
10827 *    Functionality: free the DRB to be Setup Mod list
10828 *
10829 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10830 *
10831 * @return ROK     - success
10832 *         RFAILED - failure
10833 *
10834 * ****************************************************************/
10835 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10836 {
10837    uint8_t arrIdx =0;
10838    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10839
10840    if(drbSet->list.array)
10841    {
10842       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10843       {
10844          if(drbSet->list.array[arrIdx] != NULLP)
10845          {
10846             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10847             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10848             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10849          }
10850       }
10851       CU_FREE(drbSet->list.array, drbSet->list.size);
10852    }
10853
10854 }
10855
10856 /*******************************************************************
10857  *
10858  * @brief  free the UeContextModification Request
10859  *
10860  * @details
10861  *
10862  *    Function : FreeUeContextModicationRequest
10863  *
10864  *    Functionality : deallocation of memory allocated in UeContextModiification
10865  request
10866  *
10867  * @params[in] F1AP_PDU_t *f1apMsg
10868  *
10869  * @return void
10870 *
10871 * ****************************************************************/
10872 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10873 {
10874    uint8_t arrIdx =0 , ieId=0;
10875    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10876
10877    if(f1apMsg)
10878    {
10879       if(f1apMsg->choice.initiatingMessage)
10880       {
10881          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10882          if(ueContextModifyReq->protocolIEs.list.array)
10883          {
10884             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10885             {
10886                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10887                {
10888                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10889                   switch(ieId)
10890                   {
10891                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10892                         break;
10893                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10894                         break;
10895                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10896                         {
10897                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10898                                  choice.DRBs_ToBeSetupMod_List);
10899                            break;
10900                         }
10901                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10902                         {
10903                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10904                                  choice.DRBs_ToBeModified_List);
10905                            break;
10906                         }
10907                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10908                         break;
10909                     case ProtocolIE_ID_id_RRCContainer:
10910                     {
10911                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10912                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10913                     }
10914
10915                   }
10916                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10917                }
10918             }
10919             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10920          }
10921          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10922       }
10923       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10924    }
10925 }
10926
10927 /*******************************************************************
10928  *
10929  * @brief Builds the Ue Context Modification Req
10930  *
10931  * @details
10932  *
10933  *    Function : BuildAndSendUeContextModificationReq
10934  *
10935  *    Functionality: Constructs the Ue Context Modification Req
10936  *
10937  * @params[in]
10938  *
10939  * @return ROK     - success
10940  *         RFAILED - failure
10941  *
10942  * ****************************************************************/
10943 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10944 {
10945    uint8_t    ieIdx = 0;
10946    uint8_t    elementCnt = 0;
10947    uint8_t    ret = RFAILED;
10948    uint16_t   tmpBufIdx = 0, bufIdx = 0;
10949    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10950    F1AP_PDU_t *f1apMsg = NULLP;
10951    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10952    RRCContainer_t rrcContainerTmp, *rrcContainer = NULLP;
10953    asn_enc_rval_t         encRetVal;
10954    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10955    while(1)
10956    {
10957       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10958       if(f1apMsg == NULLP)
10959       {
10960          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10961          break;
10962       }
10963
10964       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10965
10966       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10967       if(f1apMsg->choice.initiatingMessage == NULLP)
10968       {
10969          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10970          break;
10971       }
10972       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10973       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10974       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10975
10976       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10977
10978       if(action == MODIFY_UE)
10979          elementCnt = 4;
10980       else if(action == QUERY_CONFIG)
10981          elementCnt = 3;
10982       else if(action == RRC_RECONFIG_COMPLETE_IND)
10983          elementCnt = 3;
10984       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10985          elementCnt = 5;
10986
10987 #ifdef NR_DRX
10988       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
10989          elementCnt++;
10990 #endif
10991       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10992       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10993
10994       /* Initialize the UE context modification members */
10995       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10996       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10997       {
10998          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10999          break;
11000       }
11001
11002       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11003       {
11004          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
11005          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
11006          {
11007             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11008             break;
11009          }
11010       }
11011
11012       ieIdx=0;
11013       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11014       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11015       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11016                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
11017       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
11018
11019       ieIdx++;
11020       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11021       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11022       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
11023                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
11024       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
11025
11026       if(action == MODIFY_UE)
11027       {
11028          /* DRB to be setup list */
11029          ieIdx++;
11030          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
11031          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11032          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11033                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
11034          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11035                   value.choice.DRBs_ToBeSetupMod_List));
11036
11037          /* DRB to be modified list */
11038          ieIdx++;
11039          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
11040          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11041          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11042                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
11043          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11044                   value.choice.DRBs_ToBeModified_List));
11045
11046          /* TODO: DRB to be release list */
11047
11048          if(ret != ROK)
11049          {
11050             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
11051             break;
11052          }
11053
11054          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
11055       }
11056       else if(action == QUERY_CONFIG)
11057       {
11058          ieIdx++;
11059          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
11060          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11061          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11062             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
11063          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
11064       }
11065       else if(action == RRC_RECONFIG_COMPLETE_IND)
11066       {
11067          ieIdx++;
11068          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
11069          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11070          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11071             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
11072          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
11073             RRCReconfigurationCompleteIndicator_true;
11074       }
11075       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11076       {
11077          ieIdx++;
11078          if(action == STOP_DATA_TX)
11079          {
11080             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11081             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11082             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11083             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11084             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11085             TransmissionActionIndicator_stop;
11086          }
11087          else if (action == RESTART_DATA_TX)
11088          {
11089             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11090             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11091             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11092             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11093             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11094             TransmissionActionIndicator_restart;
11095          }
11096
11097          ieIdx++;
11098          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11099          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11100          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCContainer;
11101          if(fillDlDcchRrcMsg(ueCb, &rrcContainerTmp, true) != ROK)
11102          {
11103             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
11104             return RFAILED;
11105          }
11106
11107          rrcContainer = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11108          rrcContainer->size = rrcContainerTmp.size + 2; /* 2 bytes of PDCP SN */
11109          CU_ALLOC(rrcContainer->buf, rrcContainer->size);
11110          memset(rrcContainer->buf, 0, rrcContainer->size);
11111          rrcContainer->buf[0] = 0x00;
11112          rrcContainer->buf[1] = ueCb->pdcpSn; //PDCP SN
11113          for(bufIdx = 2, tmpBufIdx = 0; bufIdx < rrcContainer->size; bufIdx++, tmpBufIdx++)
11114          {
11115             rrcContainer->buf[bufIdx] = rrcContainerTmp.buf[tmpBufIdx];
11116          }
11117
11118          /* RRC delivery status request */
11119          ieIdx++;
11120          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
11121          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11122          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
11123          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
11124       }
11125
11126 #ifdef NR_DRX
11127       if(DRX_TO_BE_RELEASE && ueCb->drxCfgPresent)
11128       {
11129          /* DRX Configuration Indicator */
11130          ieIdx++;
11131          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRXConfigurationIndicator;
11132          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11133          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_DRXConfigurationIndicator;
11134          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.DRXConfigurationIndicator = DRXConfigurationIndicator_release;
11135          ueCb->drxCfgPresent = false;
11136          memset(&ueCb->drxCfg, 0, sizeof(DrxCfg));
11137       }
11138 #endif
11139
11140       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11141
11142       /* Encode the F1SetupRequest type as APER */
11143       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11144       encBufSize = 0;
11145       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11146
11147       /* Encode results */
11148       if(encRetVal.encoded == ENCODE_FAIL)
11149       {
11150          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
11151                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11152          break;
11153       }
11154       else
11155       {
11156          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
11157 #if 0
11158          /* This for loop was going into an infinite loop even though encBufSize
11159           * has a small value. Hence commented this
11160           */
11161          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11162          {
11163             DU_LOG("%x",encBuf[ieIdx]);
11164          }
11165 #endif
11166       }
11167
11168       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11169       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11170       {
11171          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
11172          break;
11173       }
11174
11175       ret = ROK;
11176       break;
11177
11178    }
11179    FreeUeContextModicationRequest(f1apMsg);
11180    return ret;
11181 }
11182
11183 /*****************************************************************i
11184  *
11185 * @brief Free memory allocated for UE Context Release Command
11186 *
11187 * @details
11188 *
11189 *    Function : FreeUeContextReleaseCommand
11190 *
11191 *    Functionality:
11192 *         - Free memory allocated for UE Context Release Command
11193 *
11194 * @params[in] F1AP_PDU_t *f1apMsg
11195 * @return void
11196 *
11197 * *************************************************************/
11198 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
11199 {
11200    uint8_t ieIdx;
11201    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
11202
11203    if(f1apMsg)
11204    {
11205       if(f1apMsg->choice.initiatingMessage)
11206       {
11207          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11208          if(ueReleaseCommand->protocolIEs.list.array)
11209          {
11210             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
11211             {
11212                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11213             }
11214             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
11215          }
11216          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11217       }
11218       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11219    }
11220 }
11221 /*******************************************************************
11222  *
11223  * @brief Builds the Ue Context Release Command
11224  *
11225  * @details
11226 *
11227 *    Function : BuildAndSendUeContextReleaseCommand
11228 *
11229 *    Functionality: Constructs the Ue Context Release Command
11230 *
11231 * @params[in]
11232 *
11233 * @return ROK     - success
11234 *         RFAILED - failure
11235 *
11236 * ****************************************************************/
11237 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
11238 {
11239    bool       memAllocFailed = false;
11240    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
11241    DuDb *duDb;
11242    CuUeCb *ueCb;
11243    F1AP_PDU_t *f1apMsg = NULLP;
11244    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
11245
11246    asn_enc_rval_t         encRetVal;
11247    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
11248
11249    while(true)
11250    {
11251       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11252       if(f1apMsg == NULLP)
11253       {
11254          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
11255          break;
11256       }
11257
11258       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11259
11260       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11261       if(f1apMsg->choice.initiatingMessage == NULLP)
11262       {
11263          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
11264          break;
11265       }
11266       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
11267       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11268       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
11269
11270       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11271
11272       SEARCH_DU_DB(duIdx, duId, duDb);
11273       ueCb = &duDb->ueCb[duUeF1apId-1];
11274       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11275          elementCnt = 3;
11276       else
11277          elementCnt = 4;
11278
11279       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
11280       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
11281
11282       /* Initialize the UE context modification members */
11283       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
11284       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
11285       {
11286          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
11287          break;
11288       }
11289
11290       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11291       {
11292          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11293          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
11294          {
11295             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
11296             memAllocFailed = true;
11297             break;
11298          }
11299       }
11300
11301       if(memAllocFailed == true)
11302       {
11303          break;
11304       }
11305
11306       ieIdx=0;
11307       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11308       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11309       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11310       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
11311       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
11312
11313       ieIdx++;
11314       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11315       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11316       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11317       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
11318       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
11319
11320       /* Cause of UE context release */
11321       ieIdx++;
11322       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
11323       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11324       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11325                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
11326       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11327       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
11328                                                                                                      CauseRadioNetwork_normal_release;
11329       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11330       {
11331          /* RRC Container for RRC release */
11332          ieIdx++;
11333          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11334          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11335          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11336                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
11337          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
11338          bufLen =7;
11339          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
11340          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
11341                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
11342          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
11343          {
11344             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
11345             break;
11346          }
11347          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
11348          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
11349       }
11350       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11351
11352       /* Encode the UE Context Release Command type as APER */
11353       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11354       encBufSize = 0;
11355       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11356             encBuf);
11357
11358       /* Encode results */
11359       if(encRetVal.encoded == ENCODE_FAIL)
11360       {
11361          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11362                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11363          break;
11364       }
11365       else
11366       {
11367          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
11368          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11369          {
11370             DU_LOG("%x",encBuf[ieIdx]);
11371          }
11372       }
11373
11374       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11375       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11376       {
11377          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11378          break;
11379       }
11380
11381       ret = ROK;
11382       break;
11383
11384    }
11385    FreeUeContextReleaseCommand(f1apMsg);
11386    return ret;
11387 }
11388 /*******************************************************************
11389 *
11390 * @brief process Ue context release request
11391 *
11392 * @details
11393 *
11394 *    Function : procUeContextReleaseReq
11395 *
11396 *    Functionality:
11397 *         - process Ue context release request
11398 *
11399 * @params[in] F1AP_PDU_t *f1apMsg
11400 * @return ROK     - success
11401 *         RFAILED - failure
11402 *
11403 * ****************************************************************/
11404 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11405 {
11406    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11407
11408    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11409    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11410
11411    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11412    {
11413       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11414       {
11415          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11416             {
11417                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11418                break;
11419             }
11420          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11421             {
11422                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11423                break;
11424             }
11425          default:
11426               break;
11427       }
11428    }
11429
11430    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11431    {
11432       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11433       return RFAILED;
11434    }
11435    return ROK;
11436 }
11437 /*******************************************************************
11438 *
11439 * @brief processing of Gnb-DU config update
11440 *
11441 * @details
11442 *
11443 *    Function : procGnbDuUpdate
11444 *
11445 *    Functionality:
11446 *         - processing of Gnb-DU config update
11447 *
11448 * @params[in] F1AP_PDU_t *f1apMsg
11449 * @return ROK     - success
11450 *         RFAILED - failure
11451 *
11452 * ****************************************************************/
11453 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11454 {
11455    bool cellToBeDelete = false;
11456    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11457    uint16_t nrCellId;
11458    DuDb *duDb;
11459    CuCellCb *cellCb;
11460    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11461
11462    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11463    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11464    {
11465       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11466       {
11467          case ProtocolIE_ID_id_TransactionID:
11468             break;
11469          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11470             break;
11471          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11472             {
11473                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11474                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11475                   Served_Cells_To_Delete_List.list.array[0];
11476                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11477                cellToBeDelete = true;
11478                break;
11479             }
11480          case ProtocolIE_ID_id_gNB_DU_ID:
11481             break;
11482       }
11483    }
11484    if(BuildAndSendDUUpdateAck(duId) != ROK)
11485    {
11486       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11487       return RFAILED;
11488    }
11489 #if 0
11490    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11491     * commented this trigger for now */
11492
11493    if(cellToBeDelete == false)
11494    {
11495       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11496       if(BuildAndSendF1ResetReq() != ROK)
11497       {
11498          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11499          return RFAILED;
11500       }
11501    }
11502 #endif
11503    if(cellToBeDelete == true)
11504    {
11505       SEARCH_DU_DB(duIdx, duId, duDb);
11506       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11507       if(cellCb->numUe == 0)
11508       {
11509          memset(cellCb, 0, sizeof(CuCellCb));
11510          duDb->numCells--;
11511       }
11512       else
11513          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11514    }
11515    return ROK;
11516 }
11517
11518 /*******************************************************************
11519 *
11520 * @brief storing slice list in CU database
11521 *
11522 * @details
11523 *
11524 *    Function : buildSliceList
11525 *
11526 *    Functionality:
11527 *         - storing slice list in CU database
11528 *
11529 * @params[in] SliceSupportList_t *sliceSupportList
11530 * @return ROK     - success
11531 *         RFAILED - failure
11532 *
11533 * ****************************************************************/
11534 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11535 {
11536    uint8_t sliceListIdx = 0;
11537
11538    if(sliceSupportList)
11539    {
11540       if(sliceSupportList->list.array)
11541       {
11542          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11543          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11544          {
11545             if(sliceSupportList->list.array[sliceListIdx])
11546             {
11547                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11548                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11549                {
11550                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11551                    return RFAILED;
11552                }
11553                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11554                {
11555                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11556                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11557                }
11558                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11559                {
11560                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11561                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11562                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11563                }
11564             }
11565          }
11566       }
11567    }
11568    return ROK;
11569 }
11570
11571 /****************************************************************
11572  * @brief Function to process Srb Setup Mod List
11573  *
11574  * @details
11575  *
11576  *    Function : procSrbSetupModList
11577  *
11578  *    Functionality:
11579  *         - Function to process SRB Setup Mod List
11580  *
11581  * @params[in]
11582  * @return ROK     - success
11583  *         RFAILED - failure
11584  *
11585  * ****************************************************************/
11586 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11587 {
11588    uint8_t arrIdx = 0, srbIdx;
11589    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11590
11591    if(srbSetupList != NULLP)
11592    {
11593       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11594       {
11595          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11596          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11597          {
11598             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11599             {
11600                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11601                {
11602                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11603                   break;
11604                }
11605             }
11606          }
11607
11608       }
11609    }
11610    return ROK;
11611 }
11612
11613
11614 /****************************************************************
11615  * @brief Function to process Drb Setup Mod List
11616  *
11617  * @details
11618  *
11619  *    Function : procDrbSetupModList
11620  *
11621  *    Functionality:
11622  *         - Function to process DRB Setup Mod List
11623  *
11624  * @params[in]
11625  * @return ROK     - success
11626  *         RFAILED - failure
11627  *
11628  * ****************************************************************/
11629 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11630 {
11631    uint8_t arrIdx = 0, drbIdx;
11632    uint32_t teId = 0;
11633    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11634
11635    if(drbSetupList != NULLP)
11636    {
11637       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11638       {
11639          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11640          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11641          {
11642             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11643             {
11644                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11645                {
11646                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11647                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11648                   break;
11649                }
11650             }
11651
11652             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11653             {
11654             /* extracting teId */
11655             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11656             if(teId > 0)
11657             {
11658               if(addDrbTunnels(duId, teId)== ROK)
11659               {
11660                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11661               }
11662             }
11663             else
11664                return RFAILED;
11665             }
11666          }
11667       }
11668    }
11669    return ROK;
11670 }
11671
11672 /*******************************************************************
11673 *
11674 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11675 *
11676 * @details
11677 *
11678 *    Function : procServedCellPlmnList
11679 *
11680 *    Functionality:
11681 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11682 *         SNSSAI list
11683 *
11684 * @params[in] F1AP_PDU_t *f1apMsg
11685 * @return ROK     - success
11686 *         RFAILED - failure
11687 *
11688 * ****************************************************************/
11689 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11690 {
11691    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11692    ProtocolExtensionContainer_4624P3_t **ieExtend;
11693
11694    if(srvPlmn->list.array)
11695    {
11696       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11697       {
11698          if(srvPlmn->list.array[srvPlmnIdx])
11699          {
11700             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11701             if(*ieExtend)
11702             {
11703                if((*ieExtend)->list.array)
11704                {
11705                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11706                   {
11707                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11708                      {
11709                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11710                         {
11711                            case ProtocolIE_ID_id_TAISliceSupportList:
11712                               {
11713                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11714                                           extensionValue.choice.SliceSupportList) != ROK)
11715                                  {
11716                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11717                                     return RFAILED;
11718                                  }
11719                               }
11720                         }
11721                      }
11722                   }
11723                }
11724             }
11725          }
11726       }
11727    }
11728    return ROK;
11729 }
11730
11731 /****************************************************************
11732  * @brief Function to process Ue Context Modification Response
11733  *
11734  * @details
11735  *
11736  *    Function : procUeContextModificationResponse
11737  *
11738  *    Functionality:
11739  *         - Function to process Ue Context Modification Response
11740  *
11741  * @params[in]
11742  * @return ROK     - success
11743  *         RFAILED - failure
11744  *
11745  * ****************************************************************/
11746 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11747 {
11748    uint8_t idx=0, duIdx=0;
11749    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11750    DuDb *duDb = NULLP;
11751    CuUeCb *ueCb = NULLP;
11752    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11753
11754    SEARCH_DU_DB(duIdx, duId, duDb);
11755    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11756
11757    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11758    {
11759       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11760       {
11761           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11762              {
11763                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11764                 break;
11765              }
11766           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11767              {
11768                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11769                 ueCb = &duDb->ueCb[duUeF1apId-1];
11770                 break;
11771              }
11772           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11773              {
11774                 /* Adding Tunnels for successful DRB */
11775                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11776                 break;
11777
11778              }
11779           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11780              {
11781                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11782                 break;
11783              }
11784          case ProtocolIE_ID_id_DUtoCURRCInformation:
11785              {
11786                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11787                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11788                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11789                 {
11790                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11791                    return RFAILED;
11792                 }
11793                 break;
11794              }
11795
11796       }
11797    }
11798
11799    /* If UE is in handover and UE context is not yet created at target DU, then send
11800     * UE context setup request to target DU */
11801    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11802    {
11803       uint8_t ueIdx = 0;
11804       DuDb *tgtDuDb = NULLP;
11805       CuUeCb *ueCbInTgtDu = NULLP;
11806
11807       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11808       if(tgtDuDb)
11809       {
11810          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11811           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11812           * DB */
11813          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11814          {
11815             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11816             {
11817                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11818                break;
11819             }
11820          }
11821
11822          /* If UE context is not found in Target DU DU, send UE context setup
11823           * request */
11824          if(ueCbInTgtDu == NULLP)
11825          {
11826             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
11827             {
11828                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11829                return RFAILED;
11830             }
11831          }
11832       }
11833    }
11834
11835    return ROK;
11836 }
11837
11838 /*******************************************************************
11839 *
11840 * @brief processing of F1 setup request
11841 *
11842 * @details
11843 *
11844 *    Function : procF1SetupReq
11845 *
11846 *    Functionality:
11847 *         - processing of  F1 setup request
11848 *
11849 * @params[in] F1AP_PDU_t *f1apMsg
11850 * @return ROK     - success
11851 *         RFAILED - failure
11852 *
11853 * ****************************************************************/
11854 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11855 {
11856    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11857    uint32_t duId = 0;
11858    uint64_t nrCellId = 0;
11859    DuDb     *duDb = NULLP;
11860    CuCellCb *cellCb = NULLP;
11861    BIT_STRING_t nrcellIdentity;
11862    F1SetupRequest_t *f1SetupReq = NULLP;
11863    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11864    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11865
11866    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11867    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11868    {
11869       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11870       {
11871          case ProtocolIE_ID_id_gNB_DU_ID:
11872            {
11873               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11874               SEARCH_DU_DB(duIdx, duId, duDb);
11875               if(duDb == NULLP)
11876               {
11877                  duDb = &cuCb.duInfo[cuCb.numDu];
11878                  cuCb.numDu++;
11879               }
11880               memset(duDb, 0, sizeof(DuDb));
11881               duDb->duId = duId;
11882               *destDuId = duId;
11883               break;
11884            }
11885          case ProtocolIE_ID_id_gNB_DU_Name:
11886            {
11887               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11888               break;
11889            }
11890          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11891            {
11892                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11893                if(duServedCell->list.array)
11894                {
11895                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11896                   {
11897                      if(duServedCell->list.array[plmnidx])
11898                      {
11899                         switch(duServedCell->list.array[plmnidx]->id)
11900                         {
11901                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11902                            {
11903                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11904                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11905                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11906
11907                               bitStringToInt(&nrcellIdentity, &nrCellId);
11908                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11909                               if(cellCb == NULLP)
11910                               {
11911                                  cellCb = &duDb->cellCb[duDb->numCells];
11912                                  memset(cellCb, 0, sizeof(CuCellCb));
11913                                  cellCb->nrCellId = nrCellId;
11914                                  cellCb->cellStatus = CELL_ACTIVE;
11915                                  duDb->numCells++;
11916                               }
11917                            }
11918                         }
11919                      }
11920                   }
11921                }
11922            }
11923       }
11924    }
11925    if(ret == ROK)
11926    {
11927       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11928    }
11929    else
11930    {
11931        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11932    }
11933 }
11934
11935 /****************************************************************
11936 *
11937 * @brief processing of UE Context Release Complete
11938 *
11939 * @details
11940 *
11941 *    Function : procUeContextReleaseComplete
11942 *
11943 *    Functionality:
11944 *         - processing of UE Context Release Complete
11945 *
11946 * @params[in] F1AP_PDU_t *f1apMsg
11947 * @return ROK     - success
11948 *         RFAILED - failure
11949 *
11950 * ****************************************************************/
11951 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11952 {
11953    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
11954    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11955    DuDb *duDb = NULLP;
11956    CuUeCb *ueCb = NULLP;
11957    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11958
11959    SEARCH_DU_DB(duIdx, duId, duDb);
11960    if(!duDb)
11961    {
11962       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11963       return;
11964    }
11965
11966    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11967    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11968    {
11969       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11970       {
11971          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11972             {
11973                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11974                break;
11975             }
11976          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11977             {
11978                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11979                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11980                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11981                {
11982                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11983                   {
11984                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11985                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11986                      {
11987                         for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11988                         {
11989                            deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
11990                         }
11991                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11992                         ueCb->cellCb->numUe--;
11993                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
11994                         {
11995                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11996                            duDb->numCells--;
11997                         }
11998                         break;
11999                      }
12000                   }
12001                }
12002                memset(ueCb, 0, sizeof(CuUeCb));
12003                duDb->numUe--;
12004                break;
12005             }
12006       }
12007    }
12008 }
12009
12010 /*******************************************************************
12011  *
12012  * @brief Builds the Paging cell list
12013  *
12014  * @details
12015  *
12016  *    Function : BuildPagingCellList
12017  *
12018  *    Functionality: Build the paging cell list
12019  *
12020  * @params[in] PagingCell_list_t  *pagingCelllist,
12021  *
12022  * @return ROK     - success
12023  *         RFAILED - failure
12024  *
12025  * ****************************************************************/
12026 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
12027 {
12028    uint8_t cellIdx =0;
12029    PagingCell_ItemIEs_t *pagingCellItemIes;
12030    PagingCell_Item_t *pagingCellItem;
12031
12032    pagingCelllist->list.count = numCells;
12033    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
12034    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
12035    if(pagingCelllist->list.array == NULLP)
12036    {
12037       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12038       return RFAILED;
12039    }
12040
12041    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12042    {
12043       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12044       if(pagingCelllist->list.array[cellIdx] == NULLP)
12045       {
12046          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12047          return RFAILED;
12048       }
12049    }
12050
12051    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12052    {
12053       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12054       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
12055       pagingCellItemIes->criticality = Criticality_ignore;
12056       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
12057       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12058
12059       /* Fill NrCgi Information */
12060       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
12061    }
12062
12063    return ROK;
12064 }
12065
12066 /*******************************************************************
12067  *
12068  * @brief Deallocation of memory allocated in paging msg
12069  *
12070  * @details
12071  *
12072  *    Function :FreePagingMsg
12073  *
12074  *    Functionality: Deallocation of memory allocated in paging msg
12075  *
12076  * @params[in] F1AP_PDU_t *f1apMsg
12077  *
12078  * @return void
12079  *
12080  * ****************************************************************/
12081 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
12082 {
12083    uint8_t ieIdx, cellIdx;
12084    Paging_t   *paging;
12085    PagingCell_ItemIEs_t *pagingCellItemIes;
12086    PagingCell_Item_t *pagingCellItem;
12087    PagingCell_list_t  *pagingCelllist;
12088
12089    if(f1apMsg)
12090    {
12091       if(f1apMsg->choice.initiatingMessage)
12092       {
12093          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12094          if(paging->protocolIEs.list.array)
12095          {
12096             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
12097             {
12098                if(paging->protocolIEs.list.array[ieIdx])
12099                {
12100                   switch(paging->protocolIEs.list.array[ieIdx]->id)
12101                   {
12102                      case ProtocolIE_ID_id_UEIdentityIndexValue:
12103                      {
12104                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12105                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12106                         break;
12107                      }
12108
12109                      case ProtocolIE_ID_id_PagingIdentity:
12110                      {
12111                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
12112                         {
12113                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12114                            {
12115                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
12116                               {
12117                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12118                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12119                               }
12120                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
12121                                 sizeof(struct CNUEPagingIdentity));
12122                            }
12123                         }
12124                         break;
12125                      }
12126
12127                      case ProtocolIE_ID_id_PagingCell_List:
12128                      {
12129                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
12130                         if(pagingCelllist->list.array)
12131                         {
12132                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12133                            {
12134                               if(pagingCelllist->list.array[cellIdx])
12135                               {
12136                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12137                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
12138                                   {
12139                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12140                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
12141                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
12142                                   }
12143                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12144                               }
12145                            }
12146                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
12147                         }
12148                         break;
12149                      }
12150                   }
12151                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12152                }
12153             }
12154             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12155          }
12156          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12157       }
12158       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12159    }
12160 }
12161 /*******************************************************************
12162  *
12163  * @brief Builds and sends the paging message if UE is in idle mode
12164  *
12165  * @details
12166  *
12167  *    Function : BuildAndSendPagingMsg
12168  *
12169  *    Functionality: Builds and sends the paging message
12170  *
12171  * @params[in] uint32_t duId, uint8_t gsTmsi
12172  *
12173  * @return ROK     - success
12174  *         RFAILED - failure
12175  *
12176  * ****************************************************************/
12177 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
12178 {
12179    bool       memAllocFailed = false;
12180    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
12181    uint16_t   ueId = 0, duIdx = 0;
12182
12183    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
12184     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
12185    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
12186    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
12187
12188    F1AP_PDU_t *f1apMsg = NULLP;
12189    Paging_t   *paging = NULLP;
12190    DuDb       *duDb;
12191    asn_enc_rval_t         encRetVal;
12192
12193    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
12194
12195    SEARCH_DU_DB(duIdx, duId, duDb);
12196    if(duDb == NULLP)
12197    {
12198       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
12199       return ret;
12200    }
12201
12202    while(true)
12203    {
12204       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12205       if(f1apMsg == NULLP)
12206       {
12207          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
12208          break;
12209       }
12210
12211       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
12212
12213       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12214       if(f1apMsg->choice.initiatingMessage == NULLP)
12215       {
12216          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
12217          break;
12218       }
12219       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
12220       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12221       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
12222
12223       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12224
12225       elementCnt = 5;
12226       paging->protocolIEs.list.count = elementCnt;
12227       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
12228
12229       /* Initialize the Paging Message members */
12230       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12231       if(paging->protocolIEs.list.array == NULLP)
12232       {
12233          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
12234          break;
12235       }
12236
12237       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12238       {
12239          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12240          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
12241          {
12242             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12243             memAllocFailed = true;
12244             break;
12245          }
12246       }
12247
12248       if(memAllocFailed == true)
12249       {
12250          break;
12251       }
12252
12253       /* UE Identity Index Value */
12254       ieIdx=0;
12255       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
12256       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12257       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
12258       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
12259       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
12260       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12261             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12262       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
12263       {
12264          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12265          break;
12266       }
12267
12268       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
12269       ueId = gsTmsi % 1024;
12270       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
12271
12272       /* Paging Identity */
12273       ieIdx++;
12274       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
12275       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12276       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
12277       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
12278                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
12279       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
12280             sizeof(struct CNUEPagingIdentity));
12281       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12282       {
12283          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12284          break;
12285       }
12286
12287       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
12288                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
12289
12290       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
12291       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12292             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12293       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
12294       {
12295          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12296          break;
12297       }
12298
12299       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
12300             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
12301
12302       /* Paging Drx */
12303       ieIdx++;
12304       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
12305       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12306       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
12307       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
12308
12309       /* Paging Priority */
12310       ieIdx++;
12311       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
12312       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12313       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
12314       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
12315
12316       /* Paging Cell List */
12317       ieIdx++;
12318       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
12319       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12320       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
12321       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
12322       {
12323          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
12324          break;
12325       }
12326
12327       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12328
12329       /* Encode the UE Context Release Command type as APER */
12330       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12331       encBufSize = 0;
12332       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12333             encBuf);
12334
12335       /* Encode results */
12336       if(encRetVal.encoded == ENCODE_FAIL)
12337       {
12338          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
12339                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12340          break;
12341       }
12342       else
12343       {
12344          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
12345          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12346          {
12347             DU_LOG("%x",encBuf[ieIdx]);
12348          }
12349       }
12350
12351       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
12352       {
12353          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
12354          break;
12355       }
12356
12357       ret = ROK;
12358       break;
12359
12360    }
12361
12362    FreePagingMsg(f1apMsg);
12363    return ret;
12364 }
12365
12366 /*******************************************************************
12367  *
12368  * @brief Handles received F1AP message and sends back response
12369  *
12370  * @details
12371  *
12372  *    Function : F1APMsgHdlr
12373  *
12374  *    Functionality:
12375  *         - Decodes received F1AP control message
12376  *         - Prepares response message, encodes and sends to SCTP
12377  *
12378  * @params[in]
12379  * @return ROK     - success
12380  *         RFAILED - failure
12381  *
12382  * ****************************************************************/
12383 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12384 {
12385    int i;
12386    char *recvBuf;
12387    MsgLen copyCnt;
12388    MsgLen recvBufLen;
12389    F1AP_PDU_t *f1apMsg = NULLP;
12390    asn_dec_rval_t rval; /* Decoder return value */
12391    F1AP_PDU_t f1apasnmsg ;
12392
12393    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12394    ODU_PRINT_MSG(mBuf, 0,0);
12395
12396    /* Copy mBuf into char array to decode it */
12397    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12398    CU_ALLOC(recvBuf, (Size)recvBufLen);
12399
12400    if(recvBuf == NULLP)
12401    {
12402       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12403       return;
12404    }
12405    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12406    {
12407       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12408       return;
12409    }
12410
12411    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12412    for(i=0; i< recvBufLen; i++)
12413    {
12414       DU_LOG("%x",recvBuf[i]);
12415    }
12416
12417    /* Decoding flat buffer into F1AP messsage */
12418    f1apMsg = &f1apasnmsg;
12419    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12420
12421    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12422    CU_FREE(recvBuf, (Size)recvBufLen);
12423
12424    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12425    {
12426       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12427       return;
12428    }
12429    DU_LOG("\n");
12430    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12431
12432    switch(f1apMsg->present)
12433    {
12434       case F1AP_PDU_PR_initiatingMessage:
12435          {
12436             switch(f1apMsg->choice.initiatingMessage->value.present)
12437             {
12438                case InitiatingMessage__value_PR_Reset:
12439                   {
12440                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12441                      BuildAndSendF1ResetAck();
12442                      break;
12443                   }
12444
12445                case InitiatingMessage__value_PR_F1SetupRequest:
12446                   {
12447                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12448                      procF1SetupReq(duId, f1apMsg);
12449                      break;
12450                   }
12451
12452                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12453                   {
12454                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12455                      procGnbDuUpdate(*duId, f1apMsg);
12456                      break;
12457                   }
12458                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12459                   {
12460                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12461                      procInitULRRCMsg(*duId, f1apMsg);
12462                      break;
12463                   }
12464                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12465                   {
12466                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12467                      procUlRrcMsg(*duId, f1apMsg);
12468                      break;
12469                   }
12470
12471                case InitiatingMessage__value_PR_RRCDeliveryReport:
12472                   {
12473                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12474                      break;
12475                   }
12476                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12477                   {
12478                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12479                      procUeContextReleaseReq(*duId, f1apMsg);
12480                      break;
12481                   }
12482                default:
12483                   {
12484                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12485                            f1apMsg->choice.initiatingMessage->value.present);
12486                      return;
12487                   }
12488             }/* End of switch(initiatingMessage) */
12489             break;
12490          }
12491
12492       case F1AP_PDU_PR_successfulOutcome:
12493          {
12494             switch(f1apMsg->choice.successfulOutcome->value.present)
12495             {
12496                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12497                   {
12498                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12499                      break;
12500                   }
12501                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12502                   {
12503                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12504                      procUeContextSetupResponse(*duId, f1apMsg);
12505                      break;
12506                   }
12507                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12508                   {
12509                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12510                      procUeContextModificationResponse(*duId, f1apMsg);
12511                      break;
12512                   }
12513                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12514                   {
12515                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12516                       procUeContextReleaseComplete(*duId, f1apMsg);
12517                       break;
12518                   }
12519                default:
12520                   {
12521                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12522                            f1apMsg->choice.successfulOutcome->value.present);
12523                      return;
12524                   }
12525             }/* End of switch(successfulOutcome) */
12526             break;
12527          }
12528       default:
12529          {
12530             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12531             return;
12532          }
12533    }/* End of switch(f1apMsg->present) */
12534
12535 } /* End of F1APMsgHdlr */
12536
12537 /**********************************************************************
12538   End of file
12539  **********************************************************************/