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 "F1AP-PDU.h"
  28 #include "ModulationOrder.h"
  29 #include "BandNR.h"
  30 #include "UE-CapabilityRAT-Container.h"
  31 #include "UE-CapabilityRAT-ContainerList.h"
  32 #include "UE-CapabilityRAT-ContainerListRRC.h"
  33 #include "HandoverPreparationInformationRrc-IEs.h"
  34 #include "HandoverPreparationInformationRrc.h"
  35 #include "SupportedBandwidth.h"
  36 #include "FeatureSetUplinkPerCC.h"
  37 #include "FeatureSetDownlinkPerCC.h"
  38 #include "FeatureSets.h"
  39 #include "RF-Parameters.h"
  40 #include "UE-NR-Capability.h"
  41 #include "ProtocolExtensionContainer.h"
  42 #include "CellGroupConfigRrc.h"
  43 #include "MAC-CellGroupConfig.h"
  44 #include "SchedulingRequestConfig.h"
  45 #include "SchedulingRequestToAddMod.h"
  46 #include "BSR-Config.h"
  47 #include "TAG-Config.h"
  48 #include "TAG.h"
  49 #include "PHR-Config.h"
  50 #include "RLC-Config.h"
  51 #include "UL-AM-RLC.h"
  52 #include "DL-AM-RLC.h"
  53 #include "LogicalChannelConfig.h"
  54 #include "RLC-BearerConfig.h"
  55 #include "PhysicalCellGroupConfig.h"
  56 #include "SpCellConfig.h"
  57 #include "ServingCellConfig.h"
  58 #include "ControlResourceSet.h"
  59 #include "SearchSpace.h"
  60 #include "PDCCH-Config.h"
  61 #include "PDSCH-TimeDomainResourceAllocation.h"
  62 #include "PDSCH-TimeDomainResourceAllocationList.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "PUCCH-Config.h"
  75 #include "PUCCH-ResourceSet.h"
  76 #include "PUCCH-Resource.h"
  77 #include "PUCCH-format1.h"
  78 #include "PUCCH-FormatConfig.h"
  79 #include "BWP-UplinkDedicated.h"
  80 #include "PUSCH-ServingCellConfig.h"
  81 #include "UplinkConfig.h"
  82 #include "PDSCH-ServingCellConfig.h"
  83 #include "EUTRANQoS.h"
  84 #include "GBR-QosInformation.h"
  85 #include "DRBs-ToBeSetupMod-List.h"
  86 #include "DRBs-ToBeSetupMod-Item.h"
  87 #include "DRBs-Setup-Item.h"
  88 #include "DLUPTNLInformation-ToBeSetup-List.h"
  89 #include "DLUPTNLInformation-ToBeSetup-Item.h"
  90 #include "UPTransportLayerInformation.h"
  91 #include "GTPTunnel.h"
  92 #include "QoSInformation.h"
  93 #include "Cells-to-be-Activated-List.h"
  94 #include "DL-CCCH-Message.h"
  95 #include "SRB-ToAddModList.h"
  96 #include "SRB-ToAddMod.h"
  97 #include "RRCSetup-IEs.h"
  98 #include "RRCSetup.h"
  99 #include "DL-DCCH-Message.h"
 100 #include "RRCReconfiguration-IEs.h"
 101 #include "RRCReconfiguration.h"
 102 #include "DRB-ToAddModList.h"
 103 #include "DRB-ToAddMod.h"
 104 #include "SDAP-Config.h"
 105 #include "SSB-MTC.h"
 106 #include "MeasTiming.h"
 107 #include "MeasTimingList.h"
 108 #include "MeasurementTimingConfigurationRrc-IEs.h"
 109 #include "MeasurementTimingConfigurationRrc.h"
 110 #include "PDCP-Config.h"
 111 #include "RSRP-Range.h"
 112 #include "RSRQ-Range.h"
 113 #include "SINR-Range.h"
 114 #include "ThresholdNR.h"
 115 #include "MeasObjectToAddMod.h"
 116 #include "MeasObjectNR.h"
 117 #include "MeasObjectToAddModList.h"
 118 #include "EventTriggerConfig.h"
 119 #include "ReportConfigNR.h"
 120 #include "ReportConfigToAddMod.h"
 121 #include "ReportConfigToAddModList.h"
 122 #include "MeasIdToAddMod.h"
 123 #include "MeasIdToAddModList.h"
 124 #include "FilterCoefficient.h"
 125 #include "QuantityConfigNR.h"
 126 #include "QuantityConfig.h"
 127 #include "MeasConfigRrc.h"
 128 #include "AS-Config.h"
 129 #include "RRCReconfiguration-v1530-IEs.h"
 130 #include "CNUEPagingIdentity.h"
 131 #include "PagingCell-Item.h"
 132
 133 #include "cu_stub_sctp.h"
 134 #include "cu_stub_egtp.h"
 135 #include "cu_f1ap_msg_hdl.h"
 136 #include "cu_stub.h"
 137
 138 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 139 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 140
 141 /*******************************************************************
 142  *
 143  * @brief Sends F1 msg over SCTP
 144  *
 145  * @details
 146  *
 147  *    Function : SendF1APMsg
 148  *
 149  *    Functionality: Sends F1 msg over SCTP
 150  *
 151  * @params[in] Region region
 152  *             Pool pool
 153  * @return ROK     - success
 154  *         RFAILED - failure
 155  *
 156  * ****************************************************************/
 157 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 158 {
 159    Buffer *mBuf = NULLP;
 160
 161    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 162    {
 163       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 164       {
 165          ODU_PRINT_MSG(mBuf, 0,0);
 166
 167          if(sctpSend(duId, mBuf) != ROK)
 168          {
 169             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 170             ODU_PUT_MSG_BUF(mBuf);
 171             return RFAILED;
 172          }
 173       }
 174       else
 175       {
 176          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 177          ODU_PUT_MSG_BUF(mBuf);
 178          return RFAILED;
 179       }
 180       ODU_PUT_MSG_BUF(mBuf);
 181    }
 182    else
 183    {
 184       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 185       return RFAILED;
 186    }
 187
 188    return ROK;
 189 } /* SendF1APMsg */
 190
 191 /*******************************************************************
 192  *
 193  * @brief Builds NRCell ID
 194  *
 195  * @details
 196  *
 197  *    Function : BuildNrCellId
 198  *
 199  *    Functionality: Building the NR Cell ID
 200  *
 201  * @params[in] BIT_STRING_t *nrcell
 202  * @return ROK     - success
 203  *         RFAILED - failure
 204  *
 205  * ****************************************************************/
 206
 207 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 208 {
 209    memset(nrcell->buf, 0, nrcell->size);
 210    nrcell->buf[4]   = 16;
 211    nrcell->bits_unused = 4;
 212    nrcell->size = 5 * sizeof(uint8_t);
 213    return ROK;
 214 }
 215
 216 /********************************************************************
 217  *
 218  * @brief Builds and sends the F1SetupResponse
 219  *
 220  * @details
 221  *
 222  *    Function : BuildAndSendF1SetupRsp
 223  *
 224  *    Functionality: Constructs the F1SetupResponse message and sends
 225  *                   it back to the DU through SCTP.
 226  *
 227  * @params[in] void **buf,Buffer to which encoded pattern is written into
 228  * @params[in] int *size,size of buffer
 229  *
 230  * @return ROK     - success
 231  *         RFAILED - failure
 232  *
 233  * ****************************************************************/
 234 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 235 {
 236    uint8_t    idx,ieIdx;
 237    uint8_t    elementCnt,cellCnt;
 238    F1AP_PDU_t         *f1apMsg = NULL;
 239    F1SetupResponse_t  *f1SetupRsp;
 240    GNB_CU_Name_t      *cuName;
 241    Cells_to_be_Activated_List_t *cellToActivate;
 242    RRC_Version_t      *rrcVer;
 243    asn_enc_rval_t     encRetVal;
 244    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 245
 246    /* Allocate the memory for F1SetupRequest_t */
 247    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 248    if(f1apMsg == NULLP)
 249    {
 250       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 251       return RFAILED;
 252    }
 253    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 254
 255    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 256    if(f1apMsg->choice.successfulOutcome == NULLP)
 257    {
 258       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 259       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 260       return RFAILED;
 261    }
 262
 263    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 264    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 265    f1apMsg->choice.successfulOutcome->value.present = \
 266                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 267    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 268
 269    elementCnt = 4;
 270    f1SetupRsp->protocolIEs.list.count = elementCnt;
 271    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 272
 273    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 274          elementCnt * sizeof(F1SetupResponseIEs_t *));
 275    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 276    {
 277       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 278       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 279       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 280       return RFAILED;
 281    }
 282
 283    for(idx=0; idx<elementCnt; idx++)
 284    {
 285       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 286             sizeof(F1SetupResponseIEs_t));
 287       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 288       {
 289          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 290                elementCnt * sizeof(F1SetupResponseIEs_t *));
 291          CU_FREE(f1apMsg->choice.successfulOutcome, \
 292                sizeof(SuccessfulOutcome_t));
 293          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 294          return RFAILED;
 295       }
 296    }
 297
 298    /*TransactionID*/
 299    idx = 0;
 300    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 301    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 302    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 303                                                             F1SetupResponseIEs__value_PR_TransactionID;
 304    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 305                                                                         TRANS_ID;
 306
 307    /*CU Name*/
 308    idx++;
 309    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 310    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 311    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 312                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 313    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 314    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 315
 316    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 317    if(cuName->buf == NULLP)
 318    {
 319       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 320       {
 321          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 322                sizeof(F1SetupResponseIEs_t));
 323       }
 324       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 325             elementCnt * sizeof(F1SetupResponseIEs_t *));
 326       CU_FREE(f1apMsg->choice.successfulOutcome,\
 327             sizeof(SuccessfulOutcome_t));
 328       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 329       return RFAILED;
 330    }
 331    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 332
 333    /*Cells to be activated list*/
 334    idx++;
 335    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 336                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 337    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 338    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 339                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 340    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 341                     Cells_to_be_Activated_List;
 342    cellCnt=1;
 343    cellToActivate->list.count = cellCnt;
 344    cellToActivate->list.size = \
 345                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 346    CU_ALLOC(cellToActivate->list.array,\
 347          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 348    if(cellToActivate->list.array == NULLP)
 349    {
 350       CU_FREE(cuName->buf, sizeof(cuName->size));
 351       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 352       {
 353          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 354                sizeof(F1SetupResponseIEs_t));
 355       }
 356       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 357             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    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 363    {
 364       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 365       if(cellToActivate->list.array[ieIdx] == NULLP)
 366       {
 367          CU_FREE(cellToActivate->list.array,\
 368                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 369          CU_FREE(cuName->buf, sizeof(cuName->size));
 370          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 371          {
 372             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 373                   sizeof(F1SetupResponseIEs_t));
 374          }
 375          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 376                elementCnt * sizeof(F1SetupResponseIEs_t *));
 377          CU_FREE(f1apMsg->choice.successfulOutcome, \
 378                sizeof(SuccessfulOutcome_t));
 379          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 380          return RFAILED;
 381       }
 382    }
 383    cellToActivate->list.array[0]->id = \
 384                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 385    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 386    cellToActivate->list.array[0]->value.present = \
 387                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 388    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 389       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 390    CU_ALLOC(cellToActivate->list.array[0]->\
 391          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 392          3*sizeof(uint8_t));
 393    if(cellToActivate->list.array[0]->value.choice.\
 394          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 395    {
 396
 397       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 398       {
 399          CU_FREE(cellToActivate->list.array[ieIdx],\
 400                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 401       }
 402
 403       CU_FREE(cellToActivate->list.array,\
 404             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 405       CU_FREE(cuName->buf, sizeof(cuName->size));
 406       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 407       {
 408          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 409                sizeof(F1SetupResponseIEs_t));
 410       }
 411       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 412             elementCnt * sizeof(F1SetupResponseIEs_t *));
 413       CU_FREE(f1apMsg->choice.successfulOutcome, \
 414             sizeof(SuccessfulOutcome_t));
 415       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 416       return RFAILED;
 417    }
 418    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 419          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 420    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 421       nRCGI.nRCellIdentity.size = 5;
 422    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 423          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 424          5*sizeof(uint8_t));
 425    if(cellToActivate->list.array[0]->value.choice.\
 426          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 427    {
 428       CU_FREE(cellToActivate->list.array[0]->\
 429             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 430             3*sizeof(uint8_t));
 431       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 432       {
 433          CU_FREE(cellToActivate->list.array[ieIdx],\
 434                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 435       }
 436
 437       CU_FREE(cellToActivate->list.array,\
 438             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 439       CU_FREE(cuName->buf, sizeof(cuName->size));
 440       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 441       {
 442          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 443                sizeof(F1SetupResponseIEs_t));
 444       }
 445       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 446             elementCnt * sizeof(F1SetupResponseIEs_t *));
 447       CU_FREE(f1apMsg->choice.successfulOutcome, \
 448             sizeof(SuccessfulOutcome_t));
 449       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 450       return RFAILED;
 451    }
 452    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 453    /* RRC Version */
 454    idx++;
 455    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 456                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 457    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 458    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 459                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 460    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 461    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 462
 463    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 464    if(rrcVer->latest_RRC_Version.buf == NULLP)
 465    {
 466       CU_FREE(cuName->buf, sizeof(cuName->size));
 467       for(ieIdx=0; ieIdx<elementCnt; idx++)
 468       {
 469          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 470                sizeof(F1SetupResponseIEs_t));
 471       }
 472       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 473             elementCnt * sizeof(F1SetupResponseIEs_t *));
 474       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 475       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 476       return RFAILED;
 477    }
 478
 479    /* Need to check RRC Version */
 480    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 481    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 482    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 483    if(rrcVer->iE_Extensions == NULLP)
 484    {
 485       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 486       CU_FREE(cuName->buf, sizeof(cuName->size));
 487       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 488       {
 489          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 490                sizeof(F1SetupResponseIEs_t));
 491       }
 492       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 493             elementCnt * sizeof(F1SetupResponseIEs_t *));
 494       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 495       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 496       return RFAILED;
 497    }
 498    rrcVer->iE_Extensions->list.count = 1;
 499    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 500    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 501          sizeof(struct RRC_Version_ExtIEs *));
 502    if(rrcVer->iE_Extensions->list.array == NULLP)
 503    {
 504       CU_FREE(rrcVer->iE_Extensions,\
 505             sizeof(ProtocolExtensionContainer_4624P81_t));
 506       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 507       CU_FREE(cuName->buf, sizeof(cuName->size));
 508       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 509       {
 510          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 511                sizeof(F1SetupResponseIEs_t));
 512       }
 513       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 514             elementCnt * sizeof(F1SetupResponseIEs_t *));
 515       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 516       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 517       return RFAILED;
 518    }
 519    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 520          sizeof(struct RRC_Version_ExtIEs));
 521    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 522    {
 523       CU_FREE(rrcVer->iE_Extensions->list.array,\
 524             sizeof(struct RRC_Version_ExtIEs *));
 525       CU_FREE(rrcVer->iE_Extensions,\
 526             sizeof(ProtocolExtensionContainer_4624P81_t));
 527       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 528       CU_FREE(cuName->buf, sizeof(cuName->size));
 529       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 530       {
 531          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 532                sizeof(F1SetupResponseIEs_t));
 533       }
 534       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 535             elementCnt * sizeof(F1SetupResponseIEs_t *));
 536       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 537       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 538       return RFAILED;
 539    }
 540    rrcVer->iE_Extensions->list.array[0]->id = \
 541                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 542    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 543    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 544                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 545    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 546       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 547    CU_ALLOC(rrcVer->iE_Extensions->list.\
 548          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 549          3*sizeof(uint8_t));
 550    if(rrcVer->iE_Extensions->list.\
 551          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 552    {
 553       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 554             sizeof(struct RRC_Version_ExtIEs));
 555       CU_FREE(rrcVer->iE_Extensions->list.array,\
 556             sizeof(struct RRC_Version_ExtIEs *));
 557       CU_FREE(rrcVer->iE_Extensions,\
 558             sizeof(ProtocolExtensionContainer_4624P81_t));
 559       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 560       CU_FREE(cuName->buf, sizeof(cuName->size));
 561       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 562       {
 563          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 564                sizeof(F1SetupResponseIEs_t));
 565       }
 566       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 567             elementCnt * sizeof(F1SetupResponseIEs_t *));
 568       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 569       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 570       return RFAILED;
 571    }
 572    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 573       Latest_RRC_Version_Enhanced.buf[0] = 0;
 574    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 575       Latest_RRC_Version_Enhanced.buf[1] = 5;
 576    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 577       Latest_RRC_Version_Enhanced.buf[2] = 15;
 578
 579    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 580
 581    /* Encode the F1SetupRequest type as UPER */
 582    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 583    encBufSize = 0;
 584    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 585
 586    /* Clean up */
 587    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 588    CU_FREE(cuName->buf, sizeof(cuName->size));
 589    for(idx=0; idx<elementCnt; idx++)
 590    {
 591       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 592    }
 593    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 594    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 595    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 596
 597    /* Check encode results */
 598    if(encRetVal.encoded == ENCODE_FAIL)
 599    {
 600       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 601             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 602       return RFAILED;
 603    }
 604    else
 605    {
 606       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 607       for(int i=0; i< encBufSize; i++)
 608       {
 609          DU_LOG("%x",encBuf[i]);
 610       }
 611    }
 612
 613    /* Sending msg */
 614    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 615    {
 616       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 617       return RFAILED;
 618    }
 619
 620    return ROK;
 621 }/* End of BuildAndSendF1SetupRsp */
 622
 623 /*******************************************************************
 624  *
 625  * @brief Builds and sends the DUUpdateAcknowledge
 626  *
 627  * @details
 628  *
 629  *    Function : BuildAndSendDUUpdateAck
 630  *
 631  *    Functionality: Constructs the DU Update Acknowledge message and sends
 632  *                   it to the DU through SCTP.
 633  *
 634  * @params[in]
 635  *
 636  * @return ROK     - success
 637  *         RFAILED - failure
 638  *
 639  * ****************************************************************/
 640
 641 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 642 {
 643    uint8_t   idx;
 644    uint8_t   elementCnt;
 645    F1AP_PDU_t *f1apMsg = NULL;
 646    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 647    asn_enc_rval_t enRetVal; /* Encoder return value */
 648
 649    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 650
 651    /* Allocate the memory for F1SetupRequest_t */
 652    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 653    if(f1apMsg == NULLP)
 654    {
 655       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 656       return RFAILED;
 657    }
 658
 659    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 660
 661    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 662    if(f1apMsg->choice.successfulOutcome == NULLP)
 663    {
 664       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 665       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 666       return RFAILED;
 667    }
 668
 669    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 670    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 671    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 672    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 673
 674    elementCnt = 1;
 675    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 676    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 677
 678    /* Initialize the F1Setup members */
 679    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 680    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 681    {
 682       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 683       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 684       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 685       return RFAILED;
 686    }
 687
 688    for(idx=0; idx<elementCnt; idx++)
 689    {
 690       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 691       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 692       {
 693          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 694          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 695          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 696          return RFAILED;
 697       }
 698    }
 699
 700    /*TransactionID*/
 701    idx = 0;
 702    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 703    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 704    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 705    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 706    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 707
 708    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 709
 710    /* Encode the F1SetupRequest type as UPER */
 711    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 712    encBufSize = 0;
 713    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 714
 715    /* Clean up */
 716    for(idx=0; idx<elementCnt; idx++)
 717    {
 718       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 719    }
 720    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 721    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 722    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 723
 724    /* Checking encode results */
 725    if(enRetVal.encoded == ENCODE_FAIL)
 726    {
 727       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 728       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 729       return RFAILED;
 730    }
 731    else
 732    {
 733       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 734       for(int i=0; i< encBufSize; i++)
 735       {
 736          DU_LOG("%x",encBuf[i]);
 737       }
 738    }
 739
 740    /* Sending msg */
 741    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 742    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 743    {
 744       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 745       return RFAILED;
 746    }
 747
 748    return ROK;
 749
 750 }/* End of BuildAndSendDUUpdateAck*/
 751
 752 /*******************************************************************
 753 *
 754 * @brief deallocating the memory of  F1reset msg
 755 *
 756 * @details
 757 *
 758 *    Function : FreeF1ResetReq
 759 *
 760 *    Functionality :
 761 *         - freeing memory of F1reset request msg
 762 *
 763 * @params[in]
 764 * @return void
 765 *
 766 *
 767 * ****************************************************************/
 768 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 769 {
 770    uint8_t idx = 0;
 771    Reset_t *f1ResetMsg = NULLP;
 772
 773    if(f1apMsg)
 774    {
 775       if(f1apMsg->choice.initiatingMessage)
 776       {
 777          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 778          if(f1ResetMsg->protocolIEs.list.array)
 779          {
 780             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 781             {
 782                if(f1ResetMsg->protocolIEs.list.array[idx])
 783                {
 784                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 785                }
 786             }
 787             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 788          }
 789          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 790       }
 791       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 792    }
 793 }
 794 /*******************************************************************
 795  *
 796  * @brief build ansld ans send f1reset msg
 797  *
 798  * @details
 799  *
 800  *    Function : BuildAndSendF1ResetReq
 801  *
 802  *    Functionality: build and send f1reset msg
 803  *
 804  * @return ROK     - success
 805  *         RFAILED - failure
 806  *
 807  * ****************************************************************/
 808 uint8_t BuildAndSendF1ResetReq()
 809 {
 810    uint8_t          elementCnt=0;
 811    uint8_t          idx=0;
 812    uint8_t          ret= RFAILED;
 813    Reset_t          *f1ResetMsg = NULLP;
 814    F1AP_PDU_t       *f1apMsg = NULLP;
 815    asn_enc_rval_t   encRetVal;
 816    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 817    do
 818    {
 819       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 820       if(f1apMsg == NULLP)
 821       {
 822          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 823          break;
 824       }
 825       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 826       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 827       if(f1apMsg->choice.initiatingMessage == NULLP)
 828       {
 829          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 830          break;
 831       }
 832       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 833       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 834       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 835
 836       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 837
 838       elementCnt = 3;
 839       f1ResetMsg->protocolIEs.list.count = elementCnt;
 840       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 841
 842       /* Initialize the F1Reset members */
 843       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 844       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 845       {
 846          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 847          break;
 848       }
 849       for(idx=0; idx<elementCnt; idx++)
 850       {
 851          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 852          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 853          {
 854             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 855             break;
 856          }
 857       }
 858
 859       /*TransactionID*/
 860       idx=0;
 861       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 862       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 863       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 864       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 865
 866       /*Cause*/
 867       idx++;
 868       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 869       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 870       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 871       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 872       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 873
 874       /*Reset Type*/
 875       idx++;
 876       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 877       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 878       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 879       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 880       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 881
 882       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 883
 884       /* Encode the F1SetupRequest type as APER */
 885       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 886       encBufSize = 0;
 887       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 888             encBuf);
 889
 890       /* Encode results */
 891       if(encRetVal.encoded == ENCODE_FAIL)
 892       {
 893          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 894                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 895          break;
 896       }
 897       else
 898       {
 899          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 900          for(idx=0; idx< encBufSize; idx++)
 901          {
 902             DU_LOG("%x",encBuf[idx]);
 903          }
 904       }
 905
 906       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 907       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 908       {
 909          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 910          break;
 911       }
 912
 913       ret = ROK;
 914       break;
 915    }while(true);
 916
 917    FreeF1ResetReq(f1apMsg);
 918    return ret;
 919 }
 920
 921 /*******************************************************************
 922  *
 923  * @brief Fills Radio Bearer Config
 924  *
 925  * @details
 926  *
 927  *    Function : fillSrbCfg
 928  *
 929  *    Functionality: Fills Radio Bearer Config
 930  *
 931  * @params[in] SRB_ToAddModList *
 932  *
 933  * @return ROK     - success
 934  *         RFAILED - failure
 935  *
 936  * ****************************************************************/
 937 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 938 {
 939    uint8_t elementCnt = 0;
 940    uint8_t idx, ieId, srbIdx = 0;
 941
 942    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 943    {
 944       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 945          elementCnt++;
 946    }
 947
 948    if(bearerCfg != NULLP)
 949    {
 950       bearerCfg->list.count = elementCnt;
 951       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 952       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 953       if(bearerCfg->list.array != NULLP)
 954       {
 955          for(idx = 0; idx < elementCnt; idx++)
 956          {
 957             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 958             if(bearerCfg->list.array[idx] == NULLP)
 959             {
 960                for(ieId = 0; ieId < idx; ieId++)
 961                {
 962                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 963                }
 964                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 965                return RFAILED;
 966             }
 967          }
 968       }
 969       else
 970       {
 971          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 972          return RFAILED;
 973       }
 974
 975       idx = 0;
 976       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 977       {
 978          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 979             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 980       }
 981    }
 982    return ROK;
 983 }
 984
 985 /*******************************************************************
 986  *
 987  * @brief Fills Master CellGroup Info
 988  *
 989  * @details
 990  *
 991  *    Function : fillMasterCellGroup
 992  *
 993  *    Functionality: Fills Master Cell Group IE
 994  *
 995  * @params[in] RRCSetup_IEs_t *
 996  *
 997  * @return ROK     - success
 998  *         RFAILED - failure
 999  *
1000  * ****************************************************************/
1001
1002 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
1003 {
1004    uint8_t ret = ROK;
1005    masterCellGroup->buf = NULLP;
1006    if(ueCb->f1apMsgDb.duToCuContainer.buf)
1007    {
1008       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
1009       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
1010       if(masterCellGroup->buf != NULLP)
1011       {
1012          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
1013       }
1014       else
1015       {
1016          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
1017          ret = RFAILED;
1018       }
1019    }
1020    else
1021    {
1022       ret =  RFAILED;
1023    }
1024    return ret;
1025 }
1026
1027 /*******************************************************************
1028  *
1029  * @brief Fills RRC setup IE
1030  *
1031  * @details
1032  *
1033  *    Function : fillRRCSetupIE
1034  *
1035  *    Functionality: Fills RRC Setup IE
1036  *
1037  * @params[in] RRCSetup_IEs_t *
1038  *
1039  * @return ROK     - success
1040  *         RFAILED - failure
1041  *
1042  * ****************************************************************/
1043
1044 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1045 {
1046    uint8_t ret = ROK, srbIdx = 0;
1047    if(rrcSetupIE)
1048    {
1049       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1050       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1051       {
1052          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1053       }
1054       if(ret == ROK)
1055       {
1056          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1057       }
1058       else
1059       {
1060          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1061          ret = RFAILED;
1062       }
1063
1064       /* If SRB configuration are filled successfully in RRC Setup, mark these
1065        * configurartion as sent to UE */
1066       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1067       {
1068          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1069             ueCb->srbList[srbIdx].cfgSentToUe = true;
1070       }
1071    }
1072    return ret;
1073 }
1074 /*******************************************************************
1075  *
1076  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1077  *
1078  * @details
1079  *
1080  *    Function : fillDlCcchRrcMsg
1081  *
1082  *    Functionality: Fills DL DCCCH Message required for
1083  *                   DLRRCMessageTransfer
1084  *
1085  * @params[in] RRCContainer_t *rrcContainer
1086  *
1087  * @return ROK     - success
1088  *         RFAILED - failure
1089  *
1090  * ****************************************************************/
1091
1092 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1093 {
1094    uint8_t ret = ROK;
1095    uint16_t idx2;
1096    DL_CCCH_Message_t dl_CCCH_Msg;
1097    asn_enc_rval_t    encRetVal;
1098
1099    if(rrcContainer != NULLP)
1100    {
1101       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1102
1103       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1104       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1105       {
1106          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1107          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1108          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1109          {
1110             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1111             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1112                RRCSetup__criticalExtensions_PR_rrcSetup;
1113
1114             /* Fill RRC Setup IE */
1115             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1116                sizeof(RRCSetup_IEs_t));
1117             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1118             {
1119                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1120
1121                if(ret == ROK)
1122                {
1123                   /* encode DL-CCCH message into RRC Container */
1124                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1125                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1126                   encBufSize = 0;
1127                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1128                   /* Encode results */
1129                   if(encRetVal.encoded == ENCODE_FAIL)
1130                   {
1131                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1132                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1133                      return RFAILED;
1134                   }
1135                   else
1136                   {
1137                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1138                      for(int i = 0; i< encBufSize; i++)
1139                      {
1140                         DU_LOG("%x",encBuf[i]);
1141                      }
1142                      rrcContainer->size = encBufSize;
1143                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1144                      if(rrcContainer->buf != NULLP)
1145                      {
1146                         memset(rrcContainer->buf, 0, encBufSize);
1147                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1148                         {
1149                            rrcContainer->buf[idx2] =    encBuf[idx2];
1150                         }
1151                      }
1152                   }
1153                }
1154                else
1155                {
1156                   ret = RFAILED;
1157                }
1158             }
1159             else
1160             {
1161                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1162                ret = RFAILED;
1163             }
1164          }
1165          else
1166          {
1167             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1168             ret = RFAILED;
1169          }
1170       }
1171       else
1172       {
1173          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1174          ret = RFAILED;
1175       }
1176    }
1177    else
1178    {
1179       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1180       ret = RFAILED;
1181    }
1182 }
1183
1184 /*******************************************************************
1185  *
1186  * @brief Fills QOS flow configuration
1187  *
1188  * @details
1189  *
1190  *    Function : fillQosFlowsToAdd
1191  *
1192  *    Functionality: Fills QOS flow configuration
1193  *
1194  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1195  *
1196  * @return ROK     - success
1197  *         RFAILED - failure
1198  *
1199  * ****************************************************************/
1200 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1201 {
1202    uint8_t idx, ied, elementCnt;
1203
1204    elementCnt = 1;
1205    qosFlow->list.count = elementCnt;
1206    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1207    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1208    if(qosFlow->list.array != NULLP)
1209    {
1210       for(idx = 0; idx < elementCnt; idx++)
1211       {
1212          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1213          if(qosFlow->list.array[idx] == NULLP)
1214          {
1215             for(ied = 0; ied < idx; ied++)
1216             {
1217                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1218             }
1219             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1220             return RFAILED;
1221          }
1222       }
1223    }
1224    idx = 0;
1225    *qosFlow->list.array[idx] = 9;
1226    return ROK;
1227 }
1228
1229 /*******************************************************************
1230  *
1231  * @brief Fills CN Assoc for Drb to Add/Mod List
1232  *
1233  * @details
1234  *
1235  *    Function : fillCnAssoc
1236  *
1237  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1238  *
1239  * @params[in] struct DRB_ToAddMod__cnAssociation *
1240  *
1241  * @return ROK     - success
1242  *         RFAILED - failure
1243  *
1244  * ****************************************************************/
1245
1246 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1247 {
1248    uint8_t ret = ROK;
1249
1250    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1251    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1252    {
1253       cnAssoc->choice.eps_BearerIdentity = 5;
1254    }
1255    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1256    {
1257       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1258       if(cnAssoc->choice.sdap_Config)
1259       {
1260          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1261          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1262          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1263          cnAssoc->choice.sdap_Config->defaultDRB = true;
1264          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1265          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1266          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1267                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1268          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1269          {
1270             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1271          }
1272          else
1273          {
1274             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1275             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1276             ret = RFAILED;
1277          }
1278       }
1279       else
1280       {
1281          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1282          ret = RFAILED;
1283       }
1284    }
1285    return ret;
1286 }
1287
1288 /*******************************************************************
1289  *
1290  * @brief Fills Radio Bearer Config for Drb
1291  *
1292  * @details
1293  *
1294  *    Function : fillDrbCfg
1295  *
1296  *    Functionality: Fills Radio Bearer Config for Drb
1297  *
1298  * @params[in] drbId, DRB_ToAddModList *
1299  *
1300  * @return ROK     - success
1301  *         RFAILED - failure
1302  *
1303  * ****************************************************************/
1304 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1305 {
1306    uint8_t idx, ied, ret, elementCnt;
1307
1308    ret = ROK;
1309    if(drbCfg != NULLP)
1310    {
1311       elementCnt = 1;
1312       drbCfg->list.count = elementCnt;
1313       drbCfg->list.size =\
1314                          elementCnt * sizeof(DRB_ToAddMod_t *);
1315       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1316       if(drbCfg->list.array != NULLP)
1317       {
1318          for(idx = 0; idx < elementCnt; idx++)
1319          {
1320             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1321             if(drbCfg->list.array[idx] == NULLP)
1322             {
1323                for(ied = 0; ied < idx; ied++)
1324                {
1325                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1326                }
1327                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1328                return RFAILED;
1329             }
1330          }
1331       }
1332       else
1333       {
1334          return RFAILED;
1335       }
1336       idx = 0;
1337       /* CN ASSOCIATION */
1338       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1339       if(drbCfg->list.array[idx]->cnAssociation)
1340       {
1341          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1342       }
1343       /* DRB */
1344       drbCfg->list.array[idx]->drb_Identity = drbId;
1345    }
1346    return ret;
1347 }
1348
1349 /*******************************************************************
1350  *
1351  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1352  *
1353  * @details
1354  *
1355  *    Function : fillRrcReconfigIE
1356  *
1357  *    Functionality: Fills RRC Reconfig Message required for
1358  *                   DLRRCMessageTransfer
1359  *
1360  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1361  *
1362  * @return ROK     - success
1363  *         RFAILED - failure
1364  *
1365  * ****************************************************************/
1366
1367 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1368 {
1369    uint8_t ret = ROK;
1370    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1371    if(rrcReconfigMsg->radioBearerConfig)
1372    {
1373       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1374       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1375       {
1376          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1377
1378       }
1379       if(ret == ROK)
1380       {
1381          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1382          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1383          {
1384             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1385             if(ret == RFAILED)
1386             {
1387                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1388                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1389                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1390             }
1391          }
1392       }
1393       else
1394       {
1395          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1396          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1397       }
1398    }
1399
1400    return ret;
1401 }
1402 /*******************************************************************
1403  *
1404  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1405  *
1406  * @details
1407  *
1408  *    Function : fillDlDcchRrcMsg
1409  *
1410  *    Functionality: Fills DL DCCH Message required for
1411  *                   DLRRCMessageTransfer
1412  *
1413  * @params[in] RRCContainer_t *rrcContainer
1414  *
1415  * @return ROK     - success
1416  *         RFAILED - failure
1417  *
1418  * ****************************************************************/
1419
1420 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1421 {
1422    uint8_t ret = ROK;
1423    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1424    DL_DCCH_Message_t dl_DCCH_Msg;
1425    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1426    asn_enc_rval_t        encRetVal;
1427
1428    if(rrcContainer != NULLP)
1429    {
1430       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1431
1432       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1433       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1434       {
1435          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1436          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1437          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1438          {
1439             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1440             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1441             if(ret == ROK)
1442             {
1443                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1444                 * configurartion as sent to UE */
1445                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1446                {
1447                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1448                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1449                }
1450                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1451                {
1452                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1453                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1454                }
1455
1456                /* encode DL-DCCH message into RRC Container */
1457                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1458                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1459                encBufSize = 0;
1460                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1461                /* Encode results */
1462                if(encRetVal.encoded == ENCODE_FAIL)
1463                {
1464                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1465                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1466                   return RFAILED;
1467                }
1468                else
1469                {
1470                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1471                   for(int i = 0; i< encBufSize; i++)
1472                   {
1473                      DU_LOG("%x",encBuf[i]);
1474                   }
1475                   rrcContainer->size = encBufSize;
1476                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1477                   if(rrcContainer->buf != NULLP)
1478                   {
1479                      memset(rrcContainer->buf, 0, encBufSize);
1480                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1481                      {
1482                         rrcContainer->buf[idx2] =       encBuf[idx2];
1483                      }
1484                   }
1485                }
1486             }
1487          }
1488          else
1489          {
1490             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1491             ret = RFAILED;
1492          }
1493       }
1494       else
1495       {
1496          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1497          ret = RFAILED;
1498       }
1499    }
1500    else
1501    {
1502       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1503       ret = RFAILED;
1504    }
1505    return ret;
1506 }
1507
1508 /*******************************************************************
1509  *
1510  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1511  *
1512  * @details
1513  *
1514  *    Function : BuildDLRRCContainer
1515  *
1516  *    Functionality: Builds RRC Container IE required for
1517  *                   DLRRCMessageTransfer
1518  *
1519  * @params[in]
1520  *
1521  * @return ROK     - success
1522  *         RFAILED - failure
1523  *
1524  * ****************************************************************/
1525
1526 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1527 {
1528    uint8_t ret, bufLen;
1529
1530    ret =ROK;
1531    if(rrcMsgType == RRC_SETUP)
1532    {
1533       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1534       if(ret == RFAILED)
1535          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1536    }
1537    else if(rrcMsgType == REGISTRATION_ACCEPT)
1538    {
1539       /*Hardcoded RRC Container from reference logs*/
1540       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1541       bufLen =14;
1542       rrcContainer->size = bufLen;
1543       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1544       if(rrcContainer->buf != NULLP)
1545       {
1546          memset(rrcContainer->buf, 0, bufLen);
1547          memcpy(rrcContainer->buf, buf, bufLen);
1548       }
1549       else
1550       {
1551          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1552          ret = RFAILED;
1553       }
1554    }
1555    else if(rrcMsgType == RRC_RECONFIG)
1556    {
1557       DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Message ");
1558       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1559       if(ret == RFAILED)
1560          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1561    }
1562
1563    return ret;
1564 }
1565
1566 /*******************************************************************
1567  *
1568  * @brief Frees the DLRRCMessageTransfer
1569  *
1570  * @details
1571  *
1572  *    Function : freeDlRrcMessageTransfer
1573  *
1574  *    Functionality: Frees the DLRRCMessageTransfer
1575  *
1576  * @params[in]
1577  *
1578  * @return ROK     - success
1579  *         RFAILED - failure
1580  *
1581  * ****************************************************************/
1582 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1583 {
1584    uint8_t idx=0;
1585    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1586
1587    if(f1apMsg)
1588    {
1589       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1590       if(dlRRCMsg->protocolIEs.list.array)
1591       {
1592          idx = 3;
1593          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1594             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1595          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1596          {
1597             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1598          }
1599          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1600       }
1601       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1602    }
1603 }
1604
1605 /*******************************************************************
1606  *
1607  * @brief Builds and sends the DLRRCMessageTransfer
1608  *
1609  * @details
1610  *
1611  *    Function : BuildAndSendDLRRCMessageTransfer
1612  *
1613  *    Functionality: Constructs the DL RRC Message Transfer and sends
1614  *                   it to the CU through SCTP.
1615  *
1616  * @params[in]
1617  *
1618  * @return ROK     - success
1619  *         RFAILED - failure
1620  *
1621  * ****************************************************************/
1622 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1623 {
1624    uint8_t   elementCnt = 0;
1625    uint8_t  ieId;
1626    uint8_t  idx;
1627    F1AP_PDU_t  *f1apMsg = NULLP;
1628    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1629    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1630
1631    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1632
1633    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1634    if(f1apMsg == NULLP)
1635    {
1636       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1637       return RFAILED;
1638    }
1639
1640    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1641    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1642    if(f1apMsg->choice.initiatingMessage == NULLP)
1643    {
1644       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1645       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1646       return RFAILED;
1647    }
1648
1649    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1650    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1651    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1652    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1653
1654    elementCnt = 4;
1655    dlRRCMsg->protocolIEs.list.count = elementCnt;
1656    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1657
1658    /* Initialize the F1Setup members */
1659    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1660    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1661    {
1662       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1663       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1664       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1665       return RFAILED;
1666    }
1667
1668    for(idx=0; idx<elementCnt; idx++)
1669    {
1670       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1671       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1672       {
1673          for(ieId=0; ieId<idx; ieId++)
1674          {
1675             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1676          }
1677          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1678          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1679          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1680          return RFAILED;
1681       }
1682    }
1683
1684    /* GNB CU UE F1AP ID */
1685    idx = 0;
1686    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1687    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1688    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1689    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1690
1691    /* GNB DU UE F1AP ID */
1692    idx++;
1693    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1694    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1695    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1696    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1697
1698    /* SRBID */
1699    idx++;
1700    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1701    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1702    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1703    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1704
1705    /* RRCContainer */
1706    idx++;
1707    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1708    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1709    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1710    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1711
1712    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1713
1714    /* Encode the F1SetupRequest type as APER */
1715    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1716    encBufSize = 0;
1717    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1718          encBuf);
1719    /* Encode results */
1720    if(encRetVal.encoded == ENCODE_FAIL)
1721    {
1722       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1723             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1724       return RFAILED;
1725    }
1726    else
1727    {
1728       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1729       for(int i=0; i< encBufSize; i++)
1730       {
1731          DU_LOG("%x",encBuf[i]);
1732       }
1733    }
1734
1735    /* Sending  msg  */
1736    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1737    {
1738       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1739       return RFAILED;
1740    }
1741    freeDlRrcMessageTransfer(f1apMsg);
1742    return ROK;
1743 }/* End of BuildAndSendDLRRCMessageTransfer */
1744
1745 /*******************************************************************
1746  *
1747  * @brief Function to set the Dl RRC Msg Type
1748  *
1749  * @details
1750  *
1751  *    Function : setDlRRCMsgType
1752  *
1753  *    Functionality: Constructs the UE Setup Response and sends
1754  *                   it to the DU through SCTP.
1755  *
1756  * @params[in]
1757  *
1758  * @return ROK     - success
1759  *         RFAILED - failure
1760  *
1761  * ****************************************************************/
1762
1763 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1764 {
1765    uint8_t rrcMsgType = 0;
1766    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1767    {
1768       case RRC_SETUP:
1769          rrcMsgType = RRC_SETUP;
1770          break;
1771       case REGISTRATION_ACCEPT:
1772          rrcMsgType = REGISTRATION_ACCEPT;
1773          break;
1774       case UE_CONTEXT_SETUP_REQ:
1775          rrcMsgType = UE_CONTEXT_SETUP_REQ;
1776          break;
1777       case SECURITY_MODE_COMPLETE:
1778          rrcMsgType = SECURITY_MODE_COMPLETE;
1779          break;
1780       case RRC_RECONFIG:
1781          rrcMsgType = RRC_RECONFIG;
1782          break;
1783       case RRC_RECONFIG_COMPLETE:
1784          rrcMsgType = RRC_RECONFIG_COMPLETE;
1785          break;
1786       case UE_CONTEXT_MOD_REQ:
1787          rrcMsgType = UE_CONTEXT_MOD_REQ;
1788          break;
1789       default:
1790          break;
1791    }
1792    return rrcMsgType;
1793 }
1794
1795 /*******************************************************************
1796  *
1797  * @brief Extract configuration from CellGroupConfig
1798  *
1799  * @details
1800  *
1801  *    Function : extractCellGroupConfig
1802  *
1803  *    Functionality: Extract configuration from CellGroupConfig
1804  *        and store in local database
1805  *
1806  * @params[in] UE control block
1807  *             Cell Group Config
1808  *
1809  * @return ROK     - success
1810  *         RFAILED - failure
1811  *
1812  * ****************************************************************/
1813 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1814 {
1815    uint8_t rbIdx, srbIdx, drbIdx;
1816    bool    srbFound, drbFound;
1817    SrbInfo *srbCfgDb = NULLP;
1818    DrbInfo *drbCfgDb = NULLP;
1819    RlcLcCfg *rlcLcCfgDb = NULLP;
1820    MacLcCfg *macLcCfgDb = NULLP;
1821    RLC_BearerConfig_t *rlcCfg = NULLP;
1822    RLC_Config_t *rlcLcCfg = NULLP;
1823    LogicalChannelConfig_t *macLcCfg = NULLP;
1824
1825    if(ueCb == NULLP)
1826    {
1827       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
1828       return RFAILED;
1829    }
1830
1831    if(cellGrpCfg == NULLP)
1832    {
1833       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
1834       return RFAILED;
1835    }
1836
1837    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
1838    {
1839       srbFound = false;
1840       drbFound = false;
1841
1842       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
1843
1844       /* Update SRB configuration in local DB */
1845       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
1846       {
1847          /* Search if SRB entry is already present in DB */
1848          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
1849          {
1850             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
1851             {
1852               srbCfgDb = &ueCb->srbList[srbIdx];
1853               srbFound = true;
1854               break;
1855             }
1856          }
1857
1858          /* If not, add SRB to UE CB's SRB list */
1859          if(!srbFound)
1860          {
1861             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
1862             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
1863             ueCb->numSrb++;
1864          }
1865
1866          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1867          srbCfgDb->cfgSentToUe = false;
1868          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
1869          macLcCfgDb = &srbCfgDb->macLcCfg;
1870       }
1871
1872       /* Update DRB configuration in local DB */
1873       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
1874       {
1875          /* Search if DRB entry is already present in DB */
1876          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
1877          {
1878             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
1879             {
1880               drbCfgDb = &ueCb->drbList[drbIdx];
1881               drbFound = true;
1882               break;
1883             }
1884          }
1885
1886          /* If not, add DRB to UE CB's SRB list */
1887          if(!drbFound)
1888          {
1889             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
1890             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
1891             ueCb->numDrb++;
1892          }
1893
1894          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1895          drbCfgDb->cfgSentToUe = false;
1896          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
1897          macLcCfgDb = &drbCfgDb->macLcCfg;
1898       }
1899
1900
1901       /* Update RLC configuration for this RB */
1902       rlcLcCfg = rlcCfg->rlc_Config;
1903       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
1904       switch(rlcLcCfgDb->rlcMode)
1905       {
1906          case RLC_Config_PR_am:
1907             {
1908                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
1909                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
1910                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
1911                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
1912                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
1913
1914                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
1915                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
1916                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
1917                break;
1918             }
1919
1920          case RLC_Config_PR_um_Bi_Directional:
1921             {
1922                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
1923
1924                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
1925                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
1926                break;
1927             }
1928       }
1929
1930       /* Update MAC configuration for this LC */
1931       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
1932       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
1933       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
1934       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
1935       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
1936       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
1937    }
1938    return ROK;
1939 }
1940
1941 /*******************************************************************
1942  *
1943  * @brief Function to decode DU to CU RRC container
1944  *
1945  * @details
1946  *
1947  *    Function : extractDuToCuRrcCont
1948  *
1949  *    Functionality: Function to decode DU to CU RRC container
1950  *
1951  * @params[in] UE Cb
1952  *             RRC conatiner octect string to be decoded
1953  *
1954  * @return ROK     - success
1955  *         RFAILED - failure
1956  *
1957  * ****************************************************************/
1958 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
1959 {
1960    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
1961    asn_dec_rval_t rval; /* Decoder return value */
1962
1963    /* Copy the received container to UeCb */
1964    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
1965
1966    /* Decoding DU to CU RRC container octet string to cell group config */
1967    cellGrpCfgMsg = &cellGrpCfg;
1968    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
1969
1970    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
1971
1972    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1973    {
1974       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
1975       return RFAILED;
1976    }
1977    printf("\n");
1978    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
1979
1980    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
1981    {
1982       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
1983       return RFAILED;
1984    }
1985
1986    return ROK;
1987 }
1988
1989 /*******************************************************************
1990  *
1991  * @brief Function to build Initial UL RRC Message
1992  *
1993  * @details
1994  *
1995  *    Function : procInitULRRCMsg
1996  *
1997  *    Functionality: Function to build Initial UL RRC Message
1998  *
1999  * @params[in]
2000  *
2001  * @return ROK     - success
2002  *         RFAILED - failure
2003  *
2004  * ****************************************************************/
2005
2006 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2007 {
2008    uint8_t idx,cellIdx=0, duIdx=0, rrcMsgType, gnbDuUeF1apId;
2009    uint8_t ret =ROK;
2010    uint32_t nrCellId, crnti;
2011    DuDb     *duDb;
2012    CuCellCb *cellCb;
2013    CuUeCb   *ueCb;
2014    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2015
2016    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2017
2018    SEARCH_DU_DB(duIdx, duId, duDb);
2019    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2020
2021    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2022    {
2023       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2024       {
2025          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2026             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2027             break;
2028
2029          case ProtocolIE_ID_id_NRCGI:
2030             nrCellId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.buf[4] >>
2031                initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.bits_unused;
2032             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2033             if(cellCb == NULLP)
2034                return RFAILED;
2035             break;
2036
2037          case ProtocolIE_ID_id_C_RNTI:
2038             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2039             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2040             {
2041                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2042                memset(ueCb, 0, sizeof(CuUeCb));
2043                ueCb->cellCb = cellCb;
2044                ueCb->crnti = crnti;
2045                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2046                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2047                ueCb->state = UE_ATTACH_IN_PROGRESS;
2048                (duDb->numUe)++;
2049
2050                cellCb->ueCb[cellCb->numUe] = ueCb;
2051                cellCb->numUe++;
2052             }
2053             break;
2054
2055          case ProtocolIE_ID_id_RRCContainer:
2056             break;
2057
2058          case ProtocolIE_ID_id_DUtoCURRCContainer:
2059             {
2060                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2061                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2062                {
2063                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2064                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2065                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2066                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2067                   {
2068                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2069                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2070                         ueCb->f1apMsgDb.duToCuContainer.size);
2071                   }
2072                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2073                   {
2074                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2075                      ret = RFAILED;
2076                   }
2077                }
2078                else
2079                {
2080                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2081                   ret = RFAILED;
2082                }
2083                break;
2084             }
2085
2086          default:
2087             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2088             break;
2089       }
2090       if(ret == RFAILED)
2091          break;
2092    }
2093
2094    if(ret == ROK)
2095    {
2096       ueCb->f1apMsgDb.dlRrcMsgCount++;
2097       rrcMsgType = setDlRRCMsgType(ueCb);
2098       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2099    }
2100    return ret;
2101 }
2102
2103 /*******************************************************************
2104  *
2105  * @brief Builds Nrcgi
2106  *
2107  * @details
2108  *
2109  *    Function : BuildNrcgi
2110  *
2111  *    Functionality: Building the PLMN ID and NR Cell id
2112  *
2113  * @params[in] NRCGI_t *nrcgi
2114  * @return ROK     - success
2115  *         RFAILED - failure
2116  *
2117  * ****************************************************************/
2118 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2119 {
2120    uint8_t ret;
2121    uint8_t unused_bits = 4;
2122    uint8_t byteSize = 5;
2123
2124    /* Allocate Buffer Memory */
2125    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2126    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2127    if(nrcgi->pLMN_Identity.buf == NULLP)
2128    {
2129       return RFAILED;
2130    }
2131    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2132
2133    if(ret != ROK)
2134    {
2135       return RFAILED;
2136    }
2137    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2138    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2139    if(nrcgi->nRCellIdentity.buf == NULLP)
2140    {
2141       return RFAILED;
2142    }
2143    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2144
2145    return ROK;
2146 }
2147 /*******************************************************************
2148  *
2149  * @brief Builds Special cell list for UE Setup Request
2150  *
2151  * @details
2152  *
2153  *    Function : BuildSplCellList
2154  *
2155  *    Functionality: Constructs the Special Cell list for UESetReq
2156  *
2157  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2158  *
2159  * @return ROK     - success
2160  *         RFAILED - failure
2161  *
2162  * ****************************************************************/
2163 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2164 {
2165    uint8_t  cellCnt;
2166    uint8_t  idx;
2167    uint8_t  ret;
2168    cellCnt = 1;
2169    spCellLst->list.count = cellCnt;
2170    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2171    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2172    if(spCellLst->list.array == NULLP)
2173    {
2174       return RFAILED;
2175    }
2176    for(idx=0; idx<cellCnt; idx++)
2177    {
2178       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2179       if(spCellLst->list.array[idx] == NULLP)
2180       {
2181          return RFAILED;
2182       }
2183    }
2184    idx = 0;
2185    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2186    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2187    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2188
2189    /* Special Cell ID -NRCGI */
2190    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2191    if(ret != ROK)
2192    {
2193       return RFAILED;
2194    }
2195    /*Special Cell Index*/
2196    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2197    return ROK;
2198 }/* End of BuildSplCellList*/
2199
2200 /*******************************************************************
2201  *
2202  * @brief Builds SRBS to be setup
2203  *
2204  * @details
2205  *
2206  *    Function : BuildSRBSetup
2207  *
2208  *    Functionality: Constructs the SRB's for UESetReq
2209  *
2210  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2211  *
2212  * @return ROK     - success
2213  *         RFAILED - failure
2214  *
2215  * ****************************************************************/
2216 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2217 {
2218    uint8_t idx;
2219    uint8_t srbCnt;
2220
2221    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2222       srbCnt = ueCb->numSrb;
2223    else
2224       srbCnt = 1;
2225    srbSet->list.count = srbCnt;
2226    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2227    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2228    if(srbSet->list.array == NULLP)
2229    {
2230       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2231       return RFAILED;
2232    }
2233
2234    for(idx=0; idx<srbCnt; idx++)
2235    {
2236       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2237       if(srbSet->list.array[idx] == NULLP)
2238       {
2239          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2240          return RFAILED;
2241       }
2242    }
2243
2244    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2245    {
2246       idx = 0;
2247       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2248       srbSet->list.array[idx]->criticality = Criticality_ignore;
2249       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2250       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2251       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2252       ueCb->numSrb++;
2253    }
2254    else
2255    {
2256       for(idx=0; idx<srbCnt; idx++)
2257       {
2258          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2259          srbSet->list.array[idx]->criticality = Criticality_ignore;
2260          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2261          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2262       }
2263    }
2264    return ROK;
2265 }/* End of BuildSRBSetup*/
2266
2267 /*******************************************************************
2268  *
2269  * @brief Builds QOS Info for DRB Setum Item
2270  *
2271  * @details
2272  *
2273  *    Function : BuildQOSInfo
2274  *
2275  *    Functionality: Constructs the QOS Info for DRB Setup Item
2276  *
2277  * @params[in] QoSInformation_t *qosinfo
2278  *             int16_t pduSessionID
2279  *
2280  * @return ROK     - success
2281  *         RFAILED - failure
2282  *
2283  * ****************************************************************/
2284 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2285 {
2286    uint8_t elementCnt = 0, qosCntIdx = 0;
2287    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2288
2289    /* NonDynamic5QIDescriptor */
2290    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2291    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2292    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2293    {
2294       return RFAILED;
2295    }
2296
2297    if(hoInProgress)
2298       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2299    else
2300    {
2301       /*FiveQI*/
2302       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2303          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2304       else
2305          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2306
2307       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2308    }
2309
2310    if(!hoInProgress)
2311    {
2312       /*AveragingWindow*/
2313       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2314       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2315       {
2316          return RFAILED;
2317       }
2318       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2319       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2320
2321       /*MaxDataBurstVolume*/
2322       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2323       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2324       {
2325          return RFAILED;
2326       }
2327       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2328       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2329    }
2330
2331    /*nRGRAN Allocation Retention Priority*/
2332    if(hoInProgress)
2333    {
2334       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2335       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2336       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2337    }
2338    else
2339    {
2340       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2341       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2342       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2343
2344       qosInfo->priorityLevel = PriorityLevel_lowest;
2345       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2346       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2347    }
2348
2349    /* PDU session ID */
2350    if(!hoInProgress)
2351    {
2352       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2353       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2354       {
2355          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2356          return ROK;
2357       }
2358
2359       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2360       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2361
2362       if(qosIeExt)
2363       {
2364          elementCnt = NUM_QOS_EXT;
2365          qosIeExt->list.count = elementCnt;
2366          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2367
2368          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2369          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2370
2371          if(qosIeExt->list.array == NULLP)
2372          {
2373             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2374             return  RFAILED;
2375          }
2376
2377          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2378          {
2379             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2380             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2381             {
2382                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2383                return  RFAILED;
2384             }
2385             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2386             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2387             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2388             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2389             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2390                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2391             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2392             qosInfo->pduSessionId = pduSessionID;
2393          }
2394       }
2395       else
2396       {
2397          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2398          return RFAILED;
2399       }
2400    }
2401    return ROK;
2402 }/*End of BuildQOSInfo*/
2403
2404 /*******************************************************************
2405  *
2406  * @brief Builds SNSSAI
2407  *
2408  * @details
2409  *
2410  *    Function : BuildSNSSAI
2411  *
2412  *    Functionality: Constructs the SNSSAI For DRB list
2413  *
2414  * @params[in] SNSSAI_t *snssai
2415  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2416  *
2417  * @return ROK     - success
2418  *         RFAILED - failure
2419  *
2420  * ****************************************************************/
2421 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2422 {
2423    /*SNSSAI*/
2424    /*ssT*/
2425    snssai->sST.size = sizeof(uint8_t);
2426    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2427    if(snssai->sST.buf == NULLP)
2428    {
2429       return RFAILED;
2430    }
2431    if(!hoInProgress)
2432       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2433    else
2434       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2435
2436    /*sD*/
2437    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2438    if(snssai->sD == NULLP)
2439    {
2440       return RFAILED;
2441    }
2442    snssai->sD->size = 3 * sizeof(uint8_t);
2443    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2444    if(snssai->sD->buf == NULLP)
2445    {
2446       return RFAILED;
2447    }
2448    if(!hoInProgress)
2449       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2450    else
2451       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2452
2453    if(!hoInProgress)
2454       drbInfo->snssai = snssaiToCopy;
2455    return ROK;
2456 }/*End of BuildSNSSAI*/
2457
2458 /*******************************************************************
2459  *
2460  * @brief Builds the flow map.
2461  *
2462  * @details
2463  *
2464  *    Function : BuildFlowsMap
2465  *
2466  *    Functionality: Constructs the flowmap For DRB list
2467  *
2468  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2469  *
2470  * @return ROK     - success
2471  *         RFAILED - failure
2472  *
2473  * ****************************************************************/
2474 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2475 {
2476    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2477    FlowsMapped *qosFlow;
2478
2479    if(!hoInProgress)
2480       flowCnt = 1;
2481    else
2482       flowCnt = drbInfo->numFlowMap;
2483    flowMap->list.count = flowCnt;
2484    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2485    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2486    if(flowMap->list.array == NULLP)
2487    {
2488       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2489       return RFAILED;
2490    }
2491    for(idx=0; idx<flowCnt; idx++)
2492    {
2493       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2494       if(flowMap->list.array[idx] == NULLP)
2495       {
2496          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2497          return RFAILED;
2498       }
2499
2500       if(!hoInProgress)
2501       {
2502          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2503          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2504          {
2505             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2506             {
2507                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2508                {
2509                   qosFlow = &drbInfo->flowMapList[flowIdx];
2510                   break;
2511                }
2512             }
2513          }
2514          else
2515          {
2516             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2517             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2518          }
2519       }
2520       else
2521       {
2522          qosFlow = &drbInfo->flowMapList[idx];
2523          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2524       }
2525
2526       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2527             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2528       if(ret != ROK)
2529       {
2530          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2531          return RFAILED;
2532       }
2533
2534       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2535          drbInfo->numFlowMap++;
2536    }
2537    return ROK;
2538 }/*End of BuildFlowsMap*/
2539
2540 /*******************************************************************
2541  *
2542  * @brief Builds the Uplink Tunnel Info
2543  *
2544  * @details
2545  *
2546  *    Function : BuildULTnlInfo
2547  *
2548  *    Functionality: Constructs the UL TnlInfo For DRB list
2549  *
2550  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2551  *
2552  * @return ROK     - success
2553  *         RFAILED - failure
2554  *
2555  * ****************************************************************/
2556 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2557 {
2558    uint8_t idx;
2559    uint8_t ulCnt;
2560
2561    ulCnt = 1;
2562    ulInfo->list.count = ulCnt;
2563    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2564    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2565    if(ulInfo->list.array == NULLP)
2566    {
2567       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2568       return RFAILED;
2569    }
2570    for(idx=0; idx<ulCnt; idx++)
2571    {
2572       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2573       if(ulInfo->list.array[idx] == NULLP)
2574       {
2575          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2576               return RFAILED;
2577       }
2578    }
2579    idx = 0;
2580    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2581    /*GTP TUNNEL*/
2582    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2583    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2584    {
2585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2586       return RFAILED;
2587    }
2588    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2589    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2590       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2591    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2592    {
2593       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2594       return RFAILED;
2595    }
2596
2597    if(!hoInProgress)
2598    {
2599       /* NOTE: Below IP address must be changed if running on different IP configuration */
2600       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2601       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2602       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2603       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2604       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2605
2606       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2607       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2608       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2609       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2610    }
2611    else
2612    {
2613       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2614       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2615       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2616       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2617       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2618    }
2619
2620    /*GTP TEID*/
2621    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2622    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2623       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2624    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2625    {
2626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2627       return RFAILED;
2628    }
2629
2630    if(!hoInProgress)
2631    {
2632       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2633       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2634       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2635       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2636
2637       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2638       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2639       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2640       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2641    }
2642    else
2643    {
2644       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2645       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2646       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2647       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2648    }
2649    return ROK;
2650 }/*End of BuildULTnlInfo*/
2651
2652 /*******************************************************************
2653  *
2654  * @brief Builds DRBS to be setup
2655  *
2656  * @details
2657  *
2658  *    Function : BuildDRBSetup
2659  *
2660  *    Functionality: Constructs the DRB's for UESetReq
2661  *
2662  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2663  *
2664  * @return ROK     - success
2665  *         RFAILED - failure
2666  *
2667  * ****************************************************************/
2668 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2669 {
2670    uint8_t idx = 0, extIeIdx = 0;
2671    uint8_t elementCnt = 0, drbCnt = 0;
2672    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2673    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2674    DRBs_ToBeSetup_Item_t *drbSetItem;
2675    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2676    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2677
2678    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2679       drbCnt = ueCb->numDrb;
2680    else
2681       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2682    drbSet->list.count = drbCnt;
2683
2684    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2685    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2686    if(drbSet->list.array == NULLP)
2687    {
2688       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2689       return RFAILED;
2690    }
2691
2692    for(idx=0; idx<drbCnt; idx++)
2693    {
2694       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2695       if(drbSet->list.array[idx] == NULLP)
2696       {
2697          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2698          return RFAILED;
2699       }
2700
2701       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2702       drbSet->list.array[idx]->criticality = Criticality_ignore;
2703       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2704       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2705       /*dRBID*/
2706       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2707       {
2708          drbSetItem->dRBID = idx + 1;
2709          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2710       }
2711       else
2712          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2713
2714       /*qoSInformation*/
2715       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2716       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2717       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2718       {
2719          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2720          return RFAILED;
2721       }
2722       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2723       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2724       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2725       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2726          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2727                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2728       else
2729          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2730                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2731       if(BuildQOSInforet != ROK)
2732       {
2733          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2734          return RFAILED;
2735       }
2736
2737       /*SNSSAI*/
2738       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2739          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2740                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
2741       else
2742          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2743                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], TRUE);
2744       if(BuildSNSSAIret != ROK)
2745       {
2746          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2747          return RFAILED;
2748       }
2749
2750       /*Flows mapped to DRB List*/
2751       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2752          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2753                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2754       else
2755          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2756                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2757       if(BuildFlowsMapret != ROK)
2758       {
2759          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2760          return RFAILED;
2761       }
2762
2763       /*ULUPTNLInformation To Be Setup List*/
2764       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2765          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2766                FALSE);
2767       else
2768          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2769                TRUE);
2770       if(BuildULTnlInforet != ROK)
2771       {
2772          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2773          return RFAILED;
2774       }
2775
2776       /*RLCMode*/
2777       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2778       {
2779          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2780          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2781       }
2782       else
2783          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2784
2785       /* DL PDCP SN Length */
2786       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2787       {
2788          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2789          if(!drbToBeSetupExt)
2790          {
2791             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2792             return RFAILED;
2793          }
2794
2795          elementCnt = 1;
2796          drbToBeSetupExt->list.count = elementCnt;
2797          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
2798
2799          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
2800          if(!drbToBeSetupExt->list.array)
2801          {
2802              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
2803              return RFAILED;
2804          }
2805
2806          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
2807          {
2808             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
2809             if(!drbToBeSetupExt->list.array[extIeIdx])
2810             {
2811                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
2812                return RFAILED;
2813             }
2814          }
2815
2816          extIeIdx = 0;
2817          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
2818
2819          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
2820          drbToBeSetupExtIe->criticality = Criticality_ignore;
2821          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
2822          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
2823          drbSetItem->iE_Extensions = drbToBeSetupExt;
2824       }
2825
2826       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2827          ueCb->numDrb++;
2828    }
2829    return ROK;
2830 }/* End of BuildDRBSetup*/
2831
2832 /*******************************************************************
2833  *
2834  * @brief Deallocating memory of function BuildAndSendUESetReq
2835  *
2836  * @details
2837  *
2838  *    Function : FreeNrcgi
2839  *
2840  *    Functionality: Deallocating memory for function BuildNrcgi
2841  *
2842  * @params[in] NRCGI_t *nrcgi
2843  *
2844  * @return void
2845  *
2846  *******************************************************************/
2847 void FreeNrcgi(NRCGI_t *nrcgi)
2848 {
2849    if(nrcgi->pLMN_Identity.buf != NULLP)
2850    {
2851       if(nrcgi->nRCellIdentity.buf != NULLP)
2852       {
2853          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2854       }
2855       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2856    }
2857 }
2858 /*******************************************************************
2859  *
2860  * @brief  Deallocating memory of function BuildAndSendUESetReq
2861  *
2862  * @details
2863  *
2864  *    Function : FreeSplCellList
2865  *
2866  *    Functionality: Deallocating memory for function BuildSplCellList
2867  *
2868  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2869  *
2870  * @return void
2871  *
2872  *
2873  * *****************************************************************/
2874 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2875 {
2876    uint8_t  cellidx;
2877    if(spCellLst->list.array != NULLP)
2878    {
2879       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2880       {
2881          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2882          {
2883             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2884          }
2885          if(spCellLst->list.array[cellidx]!=NULLP)
2886          {
2887             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2888          }
2889       }
2890       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2891    }
2892 }
2893 /*******************************************************************
2894  *
2895  * @brief Deallocating memory of function BuildAndSendUESetReq
2896  *
2897  * @details
2898  *
2899  *    Function : FreeSRBSetup
2900  *
2901  *    Functionality: Deallocating memory for function BuildSRBSetup
2902  *
2903  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2904  *
2905  * @return void
2906  *
2907  *
2908  * ******************************************************************/
2909 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2910 {
2911    uint8_t srbidx;
2912    if(srbSet->list.array != NULLP)
2913    {
2914       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2915       {
2916          if(srbSet->list.array[srbidx]!=NULLP)
2917          {
2918             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2919          }
2920       }
2921       CU_FREE(srbSet->list.array,srbSet->list.size);
2922    }
2923 }
2924 /*******************************************************************
2925  *
2926  * @brief Deallocating memory of function BuildAndSendUESetReq
2927  *
2928  * @details
2929  *
2930  *    Function : FreeQOSInfo
2931  *
2932  *    Functionality:  Deallocating memory for function BuildQOSInfo
2933  *
2934  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2935  *
2936  * @return void
2937  *
2938  * ****************************************************************/
2939 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2940 {
2941    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2942    uint8_t qosCntIdx = 0;
2943
2944    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2945    {
2946       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2947       {
2948          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2949          {
2950             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2951                   sizeof(MaxDataBurstVolume_t));
2952          }
2953          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2954                sizeof(AveragingWindow_t));
2955       }
2956       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2957             sizeof(NonDynamic5QIDescriptor_t));
2958    }
2959    if(drbQos->iE_Extensions)
2960    {
2961       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2962       if(qosIeExt->list.array != NULLP)
2963       {
2964          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2965          {
2966             if(qosIeExt->list.array[qosCntIdx])
2967             {
2968                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2969             }
2970          }
2971          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2972       }
2973
2974       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2975    }
2976 }
2977 /*******************************************************************
2978  *
2979  * @brief Deallocating memory of function BuildAndSendUESetReq
2980  *
2981  * @details
2982  *
2983  *    Function : FreeULTnlInfo
2984  *
2985  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2986  *
2987  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2988  *
2989  * @return void
2990  *
2991
2992  * ****************************************************************/
2993 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2994 {
2995    uint8_t ulidx=0;
2996    if(ulInfo->list.array != NULLP)
2997    {
2998       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2999       {
3000          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3001          {
3002             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3003             {
3004                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3005                      transportLayerAddress.buf != NULLP)
3006                {
3007                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3008                         !=NULLP)
3009                   {
3010                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3011                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3012                            gTPTunnel->gTP_TEID.size);
3013                   }
3014                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3015                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3016                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3017                }
3018                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3019                      sizeof(GTPTunnel_t));
3020             }
3021          }
3022          if(ulInfo->list.array[ulidx]!=NULLP)
3023          {
3024             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3025          }
3026       }
3027       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3028    }
3029 }
3030 /*******************************************************************
3031  *
3032  * @brief Deallocating memory for BuildAndSendUESetReq
3033  *
3034  * @details
3035  *
3036  *    Function : FreeDRBSetup
3037  *
3038  *    Functionality:  Deallocating memory for BuildDRBSetup
3039  *
3040  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3041  *
3042  * @return void
3043  *
3044  * ****************************************************************/
3045 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3046 {
3047    DRBs_ToBeSetup_Item_t *drbSetItem;
3048    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3049
3050    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3051
3052    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3053    if(drbSet->list.array != NULLP)
3054    {
3055       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3056       {
3057               if(drbSet->list.array[drbidx] != NULLP)
3058               {
3059                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3060                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3061                  {
3062                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3063                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3064                {
3065                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3066                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3067                             {
3068                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3069                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3070                                {
3071                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3072                                        {
3073                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3074                                           {
3075                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3076                                              {
3077                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3078                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3079                                                      {
3080                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3081                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3082                                                          {
3083                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3084                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3085                                                              {
3086                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3087                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3088                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3089                                                                      {
3090                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3091                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3092                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3093                                                                          {
3094                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3095                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3096                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3097                                                                                   {
3098                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3099                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3100
3101                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3102                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3103                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3104                                                                                                    sizeof(MaxDataBurstVolume_t));
3105                                                                                   }
3106                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3107                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3108                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3109                                                                          }
3110                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3111                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3112                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3113                                                                      }
3114                                                             }
3115                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3116                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3117                                                             {
3118                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3119                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3120                                                             }
3121                                                         }
3122                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3123                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3124                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3125                                                      }
3126                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3127                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3128                                             }
3129                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3130                                                               sizeof(OCTET_STRING_t));
3131                                        }
3132                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3133                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3134                                     }
3135                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3136                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3137                             }
3138                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3139                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3140                          }
3141                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3142                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3143              }
3144              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3145                         iE_Extensions != NULLP)
3146              {
3147                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3148                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3149                  if(qosIeExt->list.array != NULLP)
3150                  {
3151                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3152                    {
3153                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3154                       {
3155                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3156                       }
3157                     }
3158                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3159                   }
3160                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3161                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3162               }
3163
3164                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3165                 }
3166                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3167               }
3168       }
3169       CU_FREE(drbSet->list.array,drbSet->list.size);
3170    }
3171 }
3172
3173
3174 /*******************************************************************
3175  *
3176  * @brief Free the UE Setup Request
3177  *
3178  * @details
3179  *
3180  *    Function : FreeUeContextSetupReq
3181  *
3182  *    Functionality: Deallocate the memory of BuildUESetReq
3183  *
3184  * @params[in]  F1AP_PDU_t  *f1apMsg
3185  *
3186  * @return void
3187  *
3188  *
3189  * ****************************************************************/
3190 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3191 {
3192    uint8_t idx, ieId;
3193    UEContextSetupRequest_t  *ueSetReq = NULLP;
3194
3195    if(f1apMsg != NULLP)
3196    {
3197       if(f1apMsg->choice.initiatingMessage != NULLP)
3198       {
3199          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3200          if(ueSetReq->protocolIEs.list.array != NULLP)
3201          {
3202             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3203             {
3204                if(ueSetReq->protocolIEs.list.array[idx])
3205                {
3206                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3207                   {
3208                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3209                         break;
3210                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3211                         break;
3212                      case ProtocolIE_ID_id_SpCell_ID:
3213                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3214                         break;
3215                      case ProtocolIE_ID_id_ServCellIndex:
3216                         break;
3217                      case ProtocolIE_ID_id_SpCellULConfigured:
3218                         break;
3219                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3220                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3221                         break;
3222                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3223                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3224                         break;
3225                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3226                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3227                         break;
3228                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3229                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3230                         break;
3231                      case ProtocolIE_ID_id_RRCContainer:
3232                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3233                         {
3234                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3235                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3236                         }
3237                         break;
3238                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3239                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3240                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3241                         break;
3242                      default:
3243                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3244                         break;
3245                   }
3246                }
3247                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3248             }
3249             for(ieId=0; ieId<idx; ieId++)
3250             {
3251                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3252                {
3253                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3254                }
3255             }
3256             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3257          }
3258          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3259       }
3260       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3261    }
3262 }
3263
3264 /**Filling cell group info **/
3265 /*******************************************************************
3266  *
3267  * @brief Build Control resource set to add/modify list
3268  *
3269  * @details
3270  *
3271  *    Function : BuildControlRSetToAddModList
3272  *
3273  *    Functionality: Build Control resource set to add/modify list
3274  *
3275  * @params[in]
3276  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3277  *
3278  * @return ROK     - success
3279  *         RFAILED - failure
3280  *
3281  * ****************************************************************/
3282    uint8_t BuildControlRSetToAddModList
3283 (
3284  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3285  )
3286 {
3287    uint8_t idx;
3288    uint8_t elementCnt;
3289    uint8_t numBytes, bitsUnused;
3290    struct ControlResourceSet *controlRSet;
3291    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3292    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3293
3294    elementCnt = 1;
3295    controlRSetList->list.count = elementCnt;
3296    controlRSetList->list.size = \
3297                                 elementCnt * sizeof(struct ControlResourceSet *);
3298
3299    controlRSetList->list.array = NULLP;
3300    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3301    if(!controlRSetList->list.array)
3302    {
3303       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3304       return RFAILED;
3305    }
3306
3307    for(idx = 0; idx < elementCnt; idx++)
3308    {
3309       controlRSetList->list.array[idx] = NULLP;
3310       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3311       if(!controlRSetList->list.array[idx])
3312       {
3313          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3314          return RFAILED;
3315       }
3316    }
3317
3318    idx=0;
3319    controlRSet = controlRSetList->list.array[idx];
3320    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3321
3322    /* Values harcoded according to our design:
3323     * size 6 bytes
3324     * 3 LSBs unsued
3325     * Bit string stored ff0000000000
3326     */
3327    numBytes = 6;
3328    bitsUnused = 3;
3329    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3330    controlRSet->frequencyDomainResources.buf = NULLP;
3331    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3332          controlRSet->frequencyDomainResources.size);
3333    if(!controlRSet->frequencyDomainResources.buf)
3334    {
3335       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3336       return RFAILED;
3337    }
3338
3339    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3340    coreset0EndPrb = CORESET0_END_PRB;
3341    coreset1StartPrb = coreset0EndPrb + 6;
3342    coreset1NumPrb = CORESET1_NUM_PRB;
3343    /* calculate the PRBs */
3344    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3345    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3346    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3347
3348    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3349    controlRSet->cce_REG_MappingType.present = \
3350                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3351
3352    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3353    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3354    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3355    controlRSet->tci_PresentInDCI = NULLP;
3356 #if 0
3357    uint8_t tciStateIdx;
3358
3359    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3360          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3361    if(!controlRset->tci_StatesPDCCH_ToAddList)
3362    {
3363       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3364       return RFAILED;
3365    }
3366
3367    elementCnt = 1;
3368    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3369    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3370    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3371          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3372       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3373       {
3374          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3375          return RFAILED;
3376       }
3377
3378    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3379    {
3380       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3381       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3382       {
3383          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3384          return RFAILED;
3385       }
3386    }
3387
3388    tciStateIdx = 0;
3389    /* TODO */
3390    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3391
3392    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3393    if(!controlRset->tci_PresentInDCI)
3394    {
3395       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3396       return RFAILED;
3397    }
3398    /* TODO */
3399    *(controlRset->tci_PresentInDCI);
3400 #endif
3401
3402    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3403    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3404    if(!controlRSet->pdcch_DMRS_ScramblingID)
3405    {
3406       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3407       return RFAILED;
3408    }
3409    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3410
3411    return ROK;
3412 } /* End BuildControlRSetToAddModList */
3413
3414 /*******************************************************************
3415  *
3416  * @brief Build search space to add/modify list
3417  *
3418  * @details
3419  *
3420  *    Function : BuildSearchSpcToAddModList
3421  *
3422  *    Functionality: Build search space to add/modify list
3423  *
3424  * @params[in]
3425  * @return ROK     - success
3426  *         RFAILED - failure
3427  *
3428  * ****************************************************************/
3429    uint8_t BuildSearchSpcToAddModList
3430 (
3431  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3432  )
3433 {
3434    uint8_t idx;
3435    uint8_t numBytes;
3436    uint8_t byteIdx;
3437    uint8_t bitsUnused;
3438    uint8_t elementCnt;
3439    struct SearchSpace *searchSpc;
3440
3441    elementCnt = 1;
3442    searchSpcList->list.count = elementCnt;
3443    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3444
3445    searchSpcList->list.array = NULLP;
3446    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3447    if(!searchSpcList->list.array)
3448    {
3449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3450       return RFAILED;
3451    }
3452
3453    for(idx = 0; idx < elementCnt; idx++)
3454    {
3455       searchSpcList->list.array[idx] = NULLP;
3456       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3457       if(!searchSpcList->list.array[idx])
3458       {
3459          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3460          return RFAILED;
3461       }
3462    }
3463
3464    idx = 0;
3465    searchSpc = searchSpcList->list.array[idx];
3466
3467    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3468
3469    searchSpc->controlResourceSetId = NULLP;
3470    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3471    if(!searchSpc->controlResourceSetId)
3472    {
3473       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3474       return RFAILED;
3475    }
3476    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3477
3478    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3479    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3480          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3481    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3482    {
3483       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3484       return RFAILED;
3485    }
3486    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3487                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3488
3489    searchSpc->duration = NULLP;
3490    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3491    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3492    if(!searchSpc->monitoringSymbolsWithinSlot)
3493    {
3494       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3495       return RFAILED;
3496    }
3497
3498    /* Values taken from reference logs :
3499     * size 2 bytes
3500     * 2 LSBs unsued
3501     * Bit string stores 8000
3502     */
3503    numBytes = 2;
3504    bitsUnused = 2;
3505
3506    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3507    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3508    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3509          searchSpc->monitoringSymbolsWithinSlot->size);
3510    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3511    {
3512       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3513       return RFAILED;
3514    }
3515
3516    byteIdx = 0;
3517    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3518                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3519    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3520    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3521
3522    searchSpc->nrofCandidates = NULLP;
3523    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3524    if(!searchSpc->nrofCandidates)
3525    {
3526       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3527       return RFAILED;
3528    }
3529
3530    searchSpc->nrofCandidates->aggregationLevel1 = \
3531                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3532    searchSpc->nrofCandidates->aggregationLevel2 = \
3533                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3534    searchSpc->nrofCandidates->aggregationLevel4 = \
3535                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3536    searchSpc->nrofCandidates->aggregationLevel8 = \
3537                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3538    searchSpc->nrofCandidates->aggregationLevel16 = \
3539                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3540
3541    searchSpc->searchSpaceType = NULLP;
3542    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3543    if(!searchSpc->searchSpaceType)
3544    {
3545       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3546       return RFAILED;
3547    }
3548
3549    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3550
3551    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3552    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3553          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3554    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3555    {
3556       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3557       return RFAILED;
3558    }
3559    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3560                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3561
3562    return ROK;
3563 }/* End BuildSearchSpcToAddModList */
3564
3565 /*******************************************************************
3566  *
3567  * @brief Builds BWP DL dedicated PDCCH config
3568  *
3569  * @details
3570  *
3571  *    Function : BuildBWPDlDedPdcchCfg
3572  *
3573  *    Functionality: Builds BWP DL dedicated PDCCH config
3574  *
3575  * @params[in] struct PDCCH_Config *pdcchCfg
3576  *
3577  * @return ROK     - success
3578  *         RFAILED - failure
3579  *
3580  * ****************************************************************/
3581 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3582 {
3583    pdcchCfg->controlResourceSetToAddModList = NULLP;
3584    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3585          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3586    if(!pdcchCfg->controlResourceSetToAddModList)
3587    {
3588       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3589       return RFAILED;
3590    }
3591
3592    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3593    {
3594       return RFAILED;
3595    }
3596
3597    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3598
3599    pdcchCfg->searchSpacesToAddModList = NULLP;
3600    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3601          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3602    if(!pdcchCfg->searchSpacesToAddModList)
3603    {
3604       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3605       return RFAILED;
3606    }
3607
3608    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3609    {
3610       return RFAILED;
3611    }
3612
3613    pdcchCfg->searchSpacesToReleaseList = NULLP;
3614    pdcchCfg->downlinkPreemption = NULLP;
3615    pdcchCfg->tpc_PUSCH = NULLP;
3616    pdcchCfg->tpc_PUCCH = NULLP;
3617    pdcchCfg->tpc_SRS = NULLP;
3618
3619    return ROK;
3620 }
3621
3622 /*******************************************************************
3623  *
3624  * @brief Builds DMRS DL PDSCH Mapping type A
3625  *
3626  * @details
3627  *
3628  *    Function : BuildDMRSDLPdschMapTypeA
3629  *
3630  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3631  *
3632  * @params[in]
3633  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3634  * @return ROK     - success
3635  *         RFAILED - failure
3636  *
3637  * ****************************************************************/
3638    uint8_t BuildDMRSDLPdschMapTypeA
3639 (
3640  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3641  )
3642 {
3643    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3644    dmrsDlCfg->choice.setup = NULLP;
3645    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3646    if(!dmrsDlCfg->choice.setup)
3647    {
3648       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3649       return RFAILED;
3650    }
3651
3652    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3653    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3654    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3655    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3656    {
3657       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3658       return RFAILED;
3659    }
3660    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3661
3662    dmrsDlCfg->choice.setup->maxLength = NULLP;
3663    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3664    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3665    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3666
3667    return ROK;
3668 }
3669
3670 /*******************************************************************
3671  *
3672  * @brief Builds TCI states to add/modify list
3673  *
3674  * @details
3675  *
3676  *    Function : BuildTCIStatesToAddModList
3677  *
3678  *    Functionality:Builds TCI states to add/modify list
3679  *
3680  * @params[in]
3681  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3682  *
3683  * @return ROK     - success
3684  *         RFAILED - failure
3685  *
3686  * ****************************************************************/
3687 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3688 {
3689    return ROK;
3690 }
3691
3692 /*******************************************************************
3693  *
3694  * @brief Builds PDSCH time domain allocation list
3695  *
3696  * @details
3697  *
3698  *    Function : BuildPdschTimeDomAllocList
3699  *
3700  *    Functionality: Builds PDSCH time domain allocation list
3701  *
3702  * @params[in]
3703  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3704  *
3705  * @return ROK     - success
3706  *         RFAILED - failure
3707  *
3708  * ****************************************************************/
3709    uint8_t BuildPdschTimeDomAllocList
3710 (
3711  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3712  )
3713 {
3714    uint8_t idx;
3715    uint8_t elementCnt;
3716    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3717
3718    timeDomAllocList->present = \
3719                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3720
3721    timeDomAllocList->choice.setup = NULLP;
3722    CU_ALLOC(timeDomAllocList->choice.setup, \
3723          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3724    if(!timeDomAllocList->choice.setup)
3725    {
3726       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3727       return RFAILED;
3728    }
3729
3730    elementCnt = 2;
3731    timeDomAllocList->choice.setup->list.count = elementCnt;
3732    timeDomAllocList->choice.setup->list.size = \
3733                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3734
3735    timeDomAllocList->choice.setup->list.array = NULLP;
3736    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3737          timeDomAllocList->choice.setup->list.size);
3738    if(!timeDomAllocList->choice.setup->list.array)
3739    {
3740       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3741       return RFAILED;
3742    }
3743
3744    for(idx = 0; idx < elementCnt; idx++)
3745    {
3746       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3747       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3748             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3749       if(!timeDomAllocList->choice.setup->list.array[idx])
3750       {
3751          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3752          return RFAILED;
3753       }
3754    }
3755
3756    idx = 0;
3757    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3758    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3759    if(!timeDomAlloc->k0)
3760    {
3761        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3762        return RFAILED;
3763    }
3764    *(timeDomAlloc->k0) = 0;
3765    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3766    timeDomAlloc->startSymbolAndLength = 66;
3767
3768    idx++;
3769    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3770    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3771    if(!timeDomAlloc->k0)
3772    {
3773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3774       return RFAILED;
3775    }
3776    *(timeDomAlloc->k0) = 1;
3777    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3778    timeDomAlloc->startSymbolAndLength = 66;
3779
3780    return ROK;
3781 }
3782
3783 /*******************************************************************
3784  *
3785  * @brief Builds PDSCH PRB Bundling type
3786  *
3787  * @details
3788  *
3789  *    Function : BuildPdschPrbBundlingType
3790  *
3791  *    Functionality: Builds PDSCH PRB Bundling type
3792  *
3793  * @params[in]
3794  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3795  *
3796  * @return ROK     - success
3797  *         RFAILED - failure
3798  *
3799  * ****************************************************************/
3800    uint8_t BuildPdschPrbBundlingType
3801 (
3802  struct PDSCH_Config__prb_BundlingType *prbBndlType
3803  )
3804 {
3805    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3806
3807    prbBndlType->choice.staticBundling = NULLP;
3808    CU_ALLOC(prbBndlType->choice.staticBundling, \
3809          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3810    if(!prbBndlType->choice.staticBundling)
3811    {
3812       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3813       return RFAILED;
3814    }
3815    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3816
3817    return ROK;
3818 }
3819
3820 /*******************************************************************
3821  *
3822  * @brief Builds BWP DL dedicated PDSCH config
3823  *
3824  * @details
3825  *
3826  *    Function : BuildBWPDlDedPdschCfg
3827  *
3828  *    Functionality: Builds BWP DL dedicated PDSCH config
3829  *
3830  * @params[in] struct PDSCH_Config *pdschCfg
3831  *
3832  * @return ROK     - success
3833  *         RFAILED - failure
3834  *
3835  * ****************************************************************/
3836 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3837 {
3838    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3839
3840    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3841    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3842          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3843    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3844    {
3845       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3846       return RFAILED;
3847    }
3848
3849    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3850    {
3851       return RFAILED;
3852    }
3853
3854    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3855    pdschCfg->tci_StatesToAddModList = NULLP;
3856    pdschCfg->tci_StatesToReleaseList = NULLP;
3857    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3858 #if 0
3859    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3860    if(!pdschCfg->tci_StatesToAddModList)
3861    {
3862       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3863       return RFAILED;
3864    }
3865    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3866    {
3867       return RFAILED;
3868    }
3869 #endif
3870
3871    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3872
3873    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3874    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3875          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3876    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3877    {
3878       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3879       return RFAILED;
3880    }
3881    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3882    {
3883       return RFAILED;
3884    }
3885    pdschCfg->pdsch_AggregationFactor = NULLP;
3886    pdschCfg->rateMatchPatternToAddModList = NULLP;
3887    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3888    pdschCfg->rateMatchPatternGroup1 = NULLP;
3889    pdschCfg->rateMatchPatternGroup2 = NULLP;
3890    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3891    pdschCfg->mcs_Table = NULLP;
3892
3893    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3894    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3895    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3896    {
3897       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3898       return RFAILED;
3899    }
3900    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3901
3902    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3903    {
3904       return RFAILED;
3905    }
3906
3907    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3908    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3909    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3910    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3911    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3912    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3913    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3914
3915    return ROK;
3916 }
3917
3918 /*******************************************************************
3919  *
3920  * @brief Builds intitial DL BWP
3921  * @details
3922  *
3923  *    Function : BuildInitialDlBWP
3924  *
3925  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3926  *
3927  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3928  *
3929  * @return ROK     - success
3930  *         RFAILED - failure
3931  *
3932  * ****************************************************************/
3933 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3934 {
3935    dlBwp->pdcch_Config = NULLP;
3936    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3937    if(!dlBwp->pdcch_Config)
3938    {
3939       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3940       return RFAILED;
3941    }
3942    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3943
3944    dlBwp->pdcch_Config->choice.setup = NULLP;
3945    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3946    if(!dlBwp->pdcch_Config->choice.setup)
3947    {
3948       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3949       return RFAILED;
3950    }
3951    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3952    {
3953       return RFAILED;
3954    }
3955
3956    dlBwp->pdsch_Config = NULLP;
3957    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3958    if(!dlBwp->pdsch_Config)
3959    {
3960       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3961       return RFAILED;
3962    }
3963    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3964
3965    dlBwp->pdsch_Config->choice.setup = NULLP;
3966    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3967    if(!dlBwp->pdsch_Config->choice.setup)
3968    {
3969       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3970       return RFAILED;
3971    }
3972
3973    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3974    {
3975       return RFAILED;
3976    }
3977
3978    dlBwp->sps_Config = NULLP;
3979    dlBwp->radioLinkMonitoringConfig = NULLP;
3980    return ROK;
3981 }
3982
3983 /*******************************************************************
3984  *
3985  * @brief Builds DMRS UL Pusch Mapping type A
3986  *
3987  * @details
3988  *
3989  *    Function : BuildDMRSULPuschMapTypeA
3990  *
3991  *    Functionality: Builds DMRS UL Pusch Mapping type A
3992  *
3993  * @params[in]
3994  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3995  * @return ROK     - success
3996  *         RFAILED - failure
3997  *
3998  * ****************************************************************/
3999    uint8_t BuildDMRSULPuschMapTypeA
4000 (
4001  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4002  )
4003 {
4004    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4005    dmrsUlCfg->choice.setup= NULLP;
4006    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4007    if(!dmrsUlCfg->choice.setup)
4008    {
4009       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4010       return RFAILED;
4011    }
4012
4013    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4014    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4015    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4016    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4017    {
4018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4019       return RFAILED;
4020    }
4021    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4022
4023    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4024    dmrsUlCfg->choice.setup->maxLength = NULLP;
4025    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4026    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4027          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4028    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4029    {
4030       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4031       return RFAILED;
4032    }
4033
4034    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4035    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4036          sizeof(long));
4037    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4038    {
4039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4040       return RFAILED;
4041    }
4042    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4043
4044    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4045    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4046    return ROK;
4047 }
4048
4049 /*******************************************************************
4050  *
4051  * @brief Build PUSCH time domain allocation list
4052  *
4053  * @details
4054  *
4055  *    Function : BuildPuschTimeDomAllocList
4056  *
4057  *    Functionality: Build PUSCH time domain allocation list
4058  *
4059  * @params[in]
4060  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4061  *
4062  * @return ROK     - success
4063  *         RFAILED - failure
4064  *
4065  * ****************************************************************/
4066    uint8_t BuildPuschTimeDomAllocList
4067 (
4068  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4069  )
4070 {
4071    uint8_t idx;
4072    uint8_t elementCnt;
4073    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4074
4075    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4076    timeDomAllocList->choice.setup = NULLP;
4077    CU_ALLOC(timeDomAllocList->choice.setup, \
4078          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4079    if(!timeDomAllocList->choice.setup)
4080    {
4081       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4082       return RFAILED;
4083    }
4084
4085    elementCnt = 2;
4086    timeDomAllocList->choice.setup->list.count = elementCnt;
4087    timeDomAllocList->choice.setup->list.size = \
4088                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4089    timeDomAllocList->choice.setup->list.array = NULLP;
4090    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4091          timeDomAllocList->choice.setup->list.size);
4092    if(!timeDomAllocList->choice.setup->list.array)
4093    {
4094       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4095       return RFAILED;
4096    }
4097
4098    for(idx = 0; idx < elementCnt; idx++)
4099    {
4100       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4101       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4102             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4103       if(!timeDomAllocList->choice.setup->list.array[idx])
4104       {
4105          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4106          return RFAILED;
4107       }
4108    }
4109
4110    idx = 0;
4111    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4112    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4113    if(!timeDomAlloc->k2)
4114    {
4115       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4116       return RFAILED;
4117    }
4118    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4119    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4120    timeDomAlloc->startSymbolAndLength = 66;
4121
4122    idx++;
4123    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4124    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4125    if(!timeDomAlloc->k2)
4126    {
4127        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4128        return RFAILED;
4129    }
4130    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4131    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4132    timeDomAlloc->startSymbolAndLength = 66;
4133
4134    return ROK;
4135 }
4136
4137 /*******************************************************************
4138  *
4139  * @brief Builds BWP UL dedicated PUSCH Config
4140  *
4141  * @details
4142  *
4143  *    Function : BuildBWPUlDedPuschCfg
4144  *
4145  *    Functionality:
4146  *      Builds BWP UL dedicated PUSCH Config
4147  *
4148  * @params[in] : PUSCH_Config_t *puschCfg
4149  *
4150  * @return ROK     - success
4151  *         RFAILED - failure
4152  *
4153  * ****************************************************************/
4154 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4155 {
4156    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4157    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4158    if(!puschCfg->dataScramblingIdentityPUSCH)
4159    {
4160       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4161       return RFAILED;
4162    }
4163    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4164
4165    puschCfg->txConfig = NULLP;
4166    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4167    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4168          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4169    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4170    {
4171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4172       return RFAILED;
4173    }
4174
4175    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4176    {
4177       return RFAILED;
4178    }
4179
4180    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4181    puschCfg->pusch_PowerControl = NULLP;
4182    puschCfg->frequencyHopping = NULLP;
4183    puschCfg->frequencyHoppingOffsetLists = NULLP;
4184    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4185
4186    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4187    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4188          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4189    if(!puschCfg->pusch_TimeDomainAllocationList)
4190    {
4191       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4192       return RFAILED;
4193    }
4194
4195    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4196    {
4197       return RFAILED;
4198    }
4199
4200    puschCfg->pusch_AggregationFactor = NULLP;
4201    puschCfg->mcs_Table = NULLP;
4202    puschCfg->mcs_TableTransformPrecoder = NULLP;
4203    puschCfg->transformPrecoder = NULLP;
4204    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4205    if(!puschCfg->transformPrecoder)
4206    {
4207       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4208       return RFAILED;
4209    }
4210    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4211
4212    puschCfg->codebookSubset = NULLP;
4213    puschCfg->maxRank = NULLP;
4214    puschCfg->rbg_Size = NULLP;
4215    puschCfg->uci_OnPUSCH = NULLP;
4216    puschCfg->tp_pi2BPSK = NULLP;
4217
4218    return ROK;
4219 }
4220
4221 /*******************************************************************
4222  *
4223  * @brief Builds BWP UL dedicated PUCCH Config
4224  *
4225  * @details
4226  *
4227  *    Function : BuildBWPUlDedPucchCfg
4228  *
4229  *    Functionality:
4230  *      Builds BWP UL dedicated PUCCH Config
4231  *
4232  * @params[in] : PUCCH_Config_t *pucchCfg
4233  *
4234  * @return ROK     - success
4235  *         RFAILED - failure
4236  *
4237  * ****************************************************************/
4238 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4239 {
4240    uint8_t arrIdx, elementCnt;
4241    uint8_t rsrcIdx, rsrcSetIdx;
4242    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4243    PUCCH_Resource_t *rsrc = NULLP;
4244
4245    //RESOURCE SET
4246    elementCnt = 1;
4247    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4248    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4249    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4250    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4251    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4252    {
4253       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4254    }
4255    rsrcSetIdx = 0;
4256    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4257    rsrcSet->pucch_ResourceSetId = 1;
4258    elementCnt = 1;
4259    rsrcSet->resourceList.list.count = elementCnt;
4260    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4261    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4262    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4263    {
4264       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4265    }
4266    rsrcIdx = 0;
4267    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4268
4269    //RESOURCE
4270    elementCnt = 1;
4271    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4272    pucchCfg->resourceToAddModList->list.count = elementCnt;
4273    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4274    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4275    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4276    {
4277       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4278    }
4279    rsrcIdx = 0;
4280    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4281    rsrc->pucch_ResourceId = 1;
4282    rsrc->startingPRB = 0;
4283    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4284    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4285    rsrc->format.choice.format1->initialCyclicShift = 0;
4286    rsrc->format.choice.format1->nrofSymbols = 4;
4287    rsrc->format.choice.format1->startingSymbolIndex = 0;
4288    rsrc->format.choice.format1->timeDomainOCC = 0;
4289
4290    //PUCCH Format 1
4291    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4292    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4293    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4294    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4295    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4296
4297    //DL DATA TO UL ACK
4298    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4299    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4300    {
4301       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4302       return RFAILED;
4303    }
4304
4305    elementCnt = 2;
4306    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4307    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4308    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4309    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4310    {
4311       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4312       return RFAILED;
4313    }
4314
4315    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4316    {
4317       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4318       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4319       {
4320           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4321           return RFAILED;
4322       }
4323    }
4324
4325    arrIdx = 0;
4326    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4327    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4328
4329    return ROK;
4330 }
4331
4332 /*******************************************************************
4333  *
4334  * @brief Fills SRS resource to add/modify list
4335  *
4336  * @details
4337  *
4338  *    Function : BuildSrsRsrcAddModList
4339  *
4340  *    Functionality: Fills SRS resource to add/modify list
4341  *
4342  * @params[in]
4343  * @return ROK     - success
4344  *         RFAILED - failure
4345  *
4346  * ****************************************************************/
4347 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4348 {
4349    uint8_t   elementCnt;
4350    uint8_t   rsrcIdx;
4351
4352    elementCnt = 1;
4353    resourceList->list.count = elementCnt;
4354    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4355    resourceList->list.array = NULLP;
4356    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4357    if(!resourceList->list.array)
4358    {
4359       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4360       return RFAILED;
4361    }
4362
4363    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4364    {
4365       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4366       if(!resourceList->list.array[rsrcIdx])
4367       {
4368          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4369          return RFAILED;
4370       }
4371    }
4372
4373    rsrcIdx = 0;
4374    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4375    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4376    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4377
4378    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4379    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4380          sizeof(struct SRS_Resource__transmissionComb__n2));
4381    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4382    {
4383       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4384       return RFAILED;
4385    }
4386    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4387       = SRS_COMB_OFFSET_N2;
4388    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4389       = SRS_CYCLIC_SHIFT_N2;
4390
4391    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4392    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4393                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4394    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4395                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4396
4397    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4398    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4399    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4400    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4401    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4402    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4403                                                                SRS_Resource__groupOrSequenceHopping_neither;
4404
4405    /* Setting resource type to aperiodic for intergration purposes */
4406    resourceList->list.array[rsrcIdx]->resourceType.present = \
4407                                                              SRS_Resource__resourceType_PR_aperiodic;
4408    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4409    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4410          sizeof(struct SRS_Resource__resourceType__aperiodic));
4411    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4412    {
4413       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4414       return RFAILED;
4415    }
4416    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4417
4418    return ROK;
4419 }
4420
4421 /*******************************************************************
4422  *
4423  * @brief Build SRS resource set Add/mod list
4424  *
4425  * @details
4426  *
4427  *    Function : BuildSrsRsrcSetAddModList
4428  *
4429  *    Functionality: Build SRS resource set Add/mod list
4430  *
4431  * @params[in]
4432  * @return ROK     - success
4433  *         RFAILED - failure
4434  *
4435  * ****************************************************************/
4436    uint8_t BuildSrsRsrcSetAddModList
4437 (
4438  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4439  )
4440 {
4441    uint8_t  elementCnt;
4442    uint8_t  rSetIdx;
4443    uint8_t  rsrcIdx;
4444    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4445
4446    elementCnt = 1;
4447    rsrcSetList->list.count = elementCnt;
4448    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4449    rsrcSetList->list.array = NULLP;
4450    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4451    if(!rsrcSetList->list.array)
4452    {
4453       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4454       return RFAILED;
4455    }
4456
4457    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4458    {
4459       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4460       if(!rsrcSetList->list.array[rSetIdx])
4461       {
4462          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4463          return RFAILED;
4464       }
4465    }
4466
4467    rSetIdx = 0;
4468    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4469
4470    /* Fill Resource Id list in resource set */
4471    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4472    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4473          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4474    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4475    {
4476       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4477       return RFAILED;
4478    }
4479
4480    elementCnt = 1;
4481    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4482    rsrcIdList->list.count = elementCnt;
4483    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4484    rsrcIdList->list.array = NULLP;
4485    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4486    if(!rsrcIdList->list.array)
4487    {
4488       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4489       return RFAILED;
4490    }
4491
4492    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4493    {
4494       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4495       if(!rsrcIdList->list.array[rsrcIdx])
4496       {
4497          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4498          return RFAILED;
4499       }
4500    }
4501
4502    rsrcIdx = 0;
4503    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4504
4505    /* Fill resource type */
4506    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4507                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4508
4509    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4510    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4511          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4512    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4513    {
4514       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4515       return RFAILED;
4516    }
4517    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4518       = APERIODIC_SRS_RESRC_TRIGGER;
4519
4520    /* TODO : Fill values for below IEs as expected by Viavi */
4521    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4522    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4523
4524
4525    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4526    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4527    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4528    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4529    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4530
4531    return ROK;
4532 }
4533
4534 /*******************************************************************
4535  *
4536  * @brief Builds BWP UL dedicated SRS Config
4537  *
4538  * @details
4539  *
4540  *    Function : BuildBWPUlDedSrsCfg
4541  *
4542  *    Functionality: Builds BWP UL dedicated SRS Config
4543  *
4544  * @params[in] SRS Config
4545  * @return ROK     - success
4546  *         RFAILED - failure
4547  *
4548  * ****************************************************************/
4549 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4550 {
4551    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4552    srsCfg->srs_ResourceSetToAddModList = NULLP;
4553    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4554          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4555    if(!srsCfg->srs_ResourceSetToAddModList)
4556    {
4557       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4558       return RFAILED;
4559    }
4560    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4561    {
4562       return RFAILED;
4563    }
4564
4565    srsCfg->srs_ResourceToReleaseList = NULLP;
4566
4567    /* Resource to Add/Modify list */
4568    srsCfg->srs_ResourceToAddModList = NULLP;
4569    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4570          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4571    if(!srsCfg->srs_ResourceToAddModList)
4572    {
4573       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4574       return RFAILED;
4575    }
4576
4577    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4578    {
4579       return RFAILED;
4580    }
4581
4582    srsCfg->tpc_Accumulation = NULLP;
4583
4584    return ROK;
4585 }
4586
4587 /*******************************************************************
4588  *
4589  * @brief Builds inital UL BWP
4590  *
4591  * @details
4592  *
4593  *    Function : BuildInitialUlBWP
4594  *
4595  *    Functionality: Builds initial UL BWP
4596  *
4597  * @params[in] BWP_UplinkDedicated_t *ulBwp
4598  * @return ROK     - success
4599  *         RFAILED - failure
4600  *
4601  * ****************************************************************/
4602 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4603 {
4604    ulBwp->pucch_Config = NULLP;
4605    ulBwp->pucch_Config = NULLP;
4606    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4607    if(!ulBwp->pucch_Config)
4608    {
4609       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4610       return RFAILED;
4611    }
4612
4613    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4614    ulBwp->pucch_Config->choice.setup = NULLP;
4615    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4616    if(!ulBwp->pucch_Config->choice.setup)
4617    {
4618       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4619       return RFAILED;
4620    }
4621
4622    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4623    {
4624       return RFAILED;
4625    }
4626
4627    /* Fill BWP UL dedicated PUSCH config */
4628    ulBwp->pusch_Config = NULLP;
4629    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4630    if(!ulBwp->pusch_Config)
4631    {
4632       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4633       return RFAILED;
4634    }
4635
4636    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4637    ulBwp->pusch_Config->choice.setup = NULLP;
4638    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4639    if(!ulBwp->pusch_Config->choice.setup)
4640    {
4641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4642       return RFAILED;
4643    }
4644
4645    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4646    {
4647       return RFAILED;
4648    }
4649
4650    ulBwp->configuredGrantConfig = NULLP;
4651
4652    /* Fill BPW UL dedicated SRS config */
4653    ulBwp->srs_Config = NULLP;
4654    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4655    if(!ulBwp->srs_Config)
4656    {
4657       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4658       return RFAILED;
4659    }
4660
4661    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4662    ulBwp->srs_Config->choice.setup = NULLP;
4663    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4664    if(!ulBwp->srs_Config->choice.setup)
4665    {
4666       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4667       return RFAILED;
4668    }
4669
4670    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4671    {
4672       return RFAILED;
4673    }
4674
4675    ulBwp->beamFailureRecoveryConfig = NULLP;
4676
4677    return ROK;
4678 }
4679
4680 /*******************************************************************
4681  *
4682  * @brief Builds Pusch Serving cell Config
4683  *
4684  * @details
4685  *
4686  *    Function : BuildPuschSrvCellCfg
4687  *
4688  *    Functionality: Builds Pusch Serving cell Config
4689  *
4690  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4691  *
4692  * @return ROK     - success
4693  *         RFAILED - failure
4694  *
4695  * ****************************************************************/
4696 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4697 {
4698    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4699    puschCfg->choice.setup = NULLP;
4700    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4701    if(!puschCfg->choice.setup)
4702    {
4703       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4704       return RFAILED;
4705    }
4706
4707    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4708    puschCfg->choice.setup->rateMatching = NULLP;
4709    puschCfg->choice.setup->xOverhead = NULLP;
4710    puschCfg->choice.setup->ext1 = NULLP;
4711    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4712    if(!puschCfg->choice.setup->ext1)
4713    {
4714       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4715       return RFAILED;
4716    }
4717
4718    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4719    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4720    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4721    {
4722       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4723       return RFAILED;
4724    }
4725    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4726
4727    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4728    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4729    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4730    {
4731       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4732       return RFAILED;
4733    }
4734    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4735    return ROK;
4736 }
4737
4738 /*******************************************************************
4739  *
4740  * @brief Builds UL config
4741  * @details
4742  *
4743  *    Function : BuildUlCfg
4744  *
4745  *    Functionality: Builds UL config in spCellCfgDed
4746  *
4747  * @params[in] UplinkConfig_t *ulCfg
4748  *
4749  * @return ROK     - success
4750  *         RFAILED - failure
4751  *
4752  * ****************************************************************/
4753 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4754 {
4755    ulCfg->initialUplinkBWP = NULLP;
4756    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4757    if(!ulCfg->initialUplinkBWP)
4758    {
4759       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4760       return RFAILED;
4761    }
4762
4763    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4764    {
4765       return RFAILED;
4766    }
4767
4768    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4769    ulCfg->uplinkBWP_ToAddModList = NULLP;
4770    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4771    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4772    if(!ulCfg->firstActiveUplinkBWP_Id)
4773    {
4774       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4775       return RFAILED;
4776    }
4777    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4778
4779    ulCfg->pusch_ServingCellConfig = NULLP;
4780    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4781          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4782    if(!ulCfg->pusch_ServingCellConfig)
4783    {
4784       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4785       return RFAILED;
4786    }
4787
4788    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4789    {
4790       return RFAILED;
4791    }
4792
4793    ulCfg->carrierSwitching = NULLP;
4794    ulCfg->ext1 = NULLP;
4795    return ROK;
4796 }
4797
4798 /*******************************************************************
4799  *
4800  * @brief Builds PDSCH serving cell config
4801  * @details
4802  *
4803  *    Function : BuildPdschSrvCellCfg
4804  *
4805  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4806  *
4807  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4808  *
4809  * @return ROK     - success
4810  *         RFAILED - failure
4811  *
4812  * ****************************************************************/
4813 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4814 {
4815    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4816    pdschCfg->choice.setup = NULLP;
4817    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4818    if(!pdschCfg->choice.setup)
4819    {
4820       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4821       return RFAILED;
4822    }
4823
4824    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4825    pdschCfg->choice.setup->xOverhead = NULLP;
4826    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4827    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4828    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4829    {
4830       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4831       return RFAILED;
4832    }
4833    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4834    pdschCfg->choice.setup->pucch_Cell = NULLP;
4835    pdschCfg->choice.setup->ext1 = NULLP;
4836
4837    return ROK;
4838 }
4839
4840 /*******************************************************************
4841  *
4842  * @brief Builds CSI Meas config
4843  * @details
4844  *
4845  *    Function : BuildCsiMeasCfg
4846  *
4847  *    Functionality: Builds CSI Meas config in spCellCfgDed
4848  *
4849  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4850  *
4851  * @return ROK     - success
4852  *         RFAILED - failure
4853  *
4854  * ****************************************************************/
4855 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4856 {
4857
4858    return ROK;
4859 }
4860
4861 /*******************************************************************
4862  *
4863  * @brief Builds Spcell config dedicated
4864  * @details
4865  *
4866  *    Function : BuildSpCellCfgDed
4867  *
4868  *    Functionality: Builds sp cell config dedicated in spCellCfg
4869  *
4870  * @params[in] ServingCellConfig_t srvCellCfg
4871  *
4872  * @return ROK     - success
4873  *         RFAILED - failure
4874  *
4875  * ****************************************************************/
4876 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4877 {
4878    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4879
4880    srvCellCfg->initialDownlinkBWP = NULLP;
4881    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4882    if(!srvCellCfg->initialDownlinkBWP)
4883    {
4884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4885       return RFAILED;
4886    }
4887
4888    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4889    {
4890       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4891       return RFAILED;
4892    }
4893    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4894    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4895
4896    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4897    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4898    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4899    {
4900       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4901       return RFAILED;
4902    }
4903    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4904
4905    srvCellCfg->bwp_InactivityTimer = NULLP;
4906
4907    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4908    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4909    if(!srvCellCfg->defaultDownlinkBWP_Id)
4910    {
4911       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4912       return RFAILED;
4913    }
4914    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4915
4916    srvCellCfg->uplinkConfig = NULLP;
4917    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4918    if(!srvCellCfg->uplinkConfig)
4919    {
4920       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4921       return RFAILED;
4922    }
4923
4924    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4925    {
4926       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4927       return RFAILED;
4928    }
4929    srvCellCfg->supplementaryUplink = NULLP;
4930    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4931
4932    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4933    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4934    if(!srvCellCfg->pdsch_ServingCellConfig)
4935    {
4936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4937       return RFAILED;
4938    }
4939
4940    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4941    {
4942       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4943       return RFAILED;
4944    }
4945
4946    srvCellCfg->csi_MeasConfig = NULLP;
4947 #if 0
4948    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4949       if(!srvCellCfg->csi_MeasConfig)
4950       {
4951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4952          return RFAILED;
4953       }
4954
4955    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4956    {
4957       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4958       return RFAILED;
4959    }
4960 #endif
4961    srvCellCfg->sCellDeactivationTimer = NULLP;
4962    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4963    srvCellCfg->tag_Id = TAG_ID;
4964    srvCellCfg->dummy = NULLP;
4965    srvCellCfg->pathlossReferenceLinking = NULLP;
4966    srvCellCfg->servingCellMO = NULLP;
4967    srvCellCfg->ext1 = NULLP;
4968
4969    return ROK;
4970 }
4971 /*******************************************************************
4972  *
4973  * @brief Builds Spcell config
4974  *
4975  * @details
4976  *
4977  *    Function : BuildSpCellCfg
4978  *
4979  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4980  *
4981  * @params[in] SpCellConfig_t spCellCfg
4982  *
4983  * @return ROK     - success
4984  *         RFAILED - failure
4985  *
4986  * ****************************************************************/
4987 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4988 {
4989
4990    spCellCfg->servCellIndex = NULLP;
4991    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4992    if(!spCellCfg->servCellIndex)
4993    {
4994       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4995       return RFAILED;
4996    }
4997    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4998
4999    spCellCfg->reconfigurationWithSync = NULLP;
5000    spCellCfg->rlf_TimersAndConstants = NULLP;
5001    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5002    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5003    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5004    {
5005       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5006       return RFAILED;
5007    }
5008    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5009
5010    spCellCfg->spCellConfigDedicated = NULLP;
5011    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5012    if(!spCellCfg->spCellConfigDedicated)
5013    {
5014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5015       return RFAILED;
5016    }
5017    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5018    {
5019       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5020       return RFAILED;
5021    }
5022    return ROK;
5023 }
5024 /*******************************************************************
5025  *
5026  * @brief Builds Phy cell group config
5027  *
5028  * @details
5029  *
5030  *    Function : BuildPhyCellGrpCfg
5031  *
5032  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5033  *
5034  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5035  *
5036  * @return ROK     - success
5037  *         RFAILED - failure
5038  *
5039  * ****************************************************************/
5040 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5041 {
5042    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5043    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5044
5045    phyCellGrpCfg->p_NR_FR1 = NULLP;
5046    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5047    if(!phyCellGrpCfg->p_NR_FR1)
5048    {
5049       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5050       return RFAILED;
5051    }
5052    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5053    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5054    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5055    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5056    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5057    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5058    phyCellGrpCfg->cs_RNTI = NULLP;
5059    phyCellGrpCfg->ext1 = NULLP;
5060    phyCellGrpCfg->ext2 = NULLP;
5061
5062    return ROK;
5063 }
5064
5065 /*******************************************************************
5066  *
5067  * @brief Builds tag config
5068  *
5069  * @details
5070  *
5071  *    Function : BuildTagConfig
5072  *
5073  *    Functionality: Builds tag config in MacCellGroupConfig
5074  *
5075  * @params[in] TAG_Config *tag_Config
5076  *
5077  * @return ROK     - success
5078  *         RFAILED - failure
5079  *
5080  * ****************************************************************/
5081 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5082 {
5083    struct TAG_Config__tag_ToAddModList *tagList;
5084    uint8_t                     idx, elementCnt;
5085
5086    tagConfig->tag_ToReleaseList = NULLP;
5087    tagConfig->tag_ToAddModList = NULLP;
5088    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5089    if(!tagConfig->tag_ToAddModList)
5090    {
5091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5092       return RFAILED;
5093    }
5094
5095    elementCnt = 1; //ODU_VALUE_ONE;
5096    tagList = tagConfig->tag_ToAddModList;
5097    tagList->list.count = elementCnt;
5098    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5099
5100    tagList->list.array = NULLP;
5101    CU_ALLOC(tagList->list.array, tagList->list.size);
5102    if(!tagList->list.array)
5103    {
5104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5105       return RFAILED;
5106    }
5107
5108    for(idx=0; idx<tagList->list.count; idx++)
5109    {
5110       tagList->list.array[idx] = NULLP;
5111       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5112       if(!tagList->list.array[idx])
5113       {
5114          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5115          return RFAILED;
5116       }
5117    }
5118
5119    idx = 0;
5120    tagList->list.array[idx]->tag_Id = TAG_ID;
5121    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5122
5123    return ROK;
5124 }
5125
5126 /*******************************************************************
5127  *
5128  * @brief Builds PHR Config
5129  *
5130  * @details
5131  *
5132  *    Function : BuildPhrConfig
5133  *
5134  *    Functionality: Builds phrConfig in MacCellGroupConfig
5135  *
5136  * @params[in] PHR Config *
5137  *
5138  * @return ROK     - success
5139  *         RFAILED - failure
5140  *
5141  * ****************************************************************/
5142 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5143 {
5144
5145    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5146    phrConfig->choice.setup = NULLP;
5147    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5148    if(!phrConfig->choice.setup)
5149    {
5150       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5151       return RFAILED;
5152    }
5153
5154    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5155    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5156    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5157    phrConfig->choice.setup->multiplePHR              = false;
5158    phrConfig->choice.setup->dummy                    = false;
5159    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5160    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5161
5162    return ROK;
5163 }
5164
5165 /*******************************************************************
5166  *
5167  * @brief Builds BSR Config
5168  *
5169  * @details
5170  *
5171  *    Function : BuildBsrConfig
5172  *
5173  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5174  *
5175  * @params[in] BSR_Config *bsrConfig
5176  *
5177  * @return ROK     - success
5178  *         RFAILED - failure
5179  *
5180  * ****************************************************************/
5181 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5182 {
5183    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5184    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5185    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5186
5187    return ROK;
5188 }
5189
5190 /*******************************************************************
5191  *
5192  * @brief Builds scheduling request config
5193  *
5194  * @details
5195  *
5196  *    Function : BuildSchedulingReqConfig
5197  *
5198  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5199  *
5200  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5201  *
5202  * @return ROK     - success
5203  *         RFAILED - failure
5204  *
5205  * ****************************************************************/
5206 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5207 {
5208    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5209    uint8_t                     idx, elementCnt;
5210
5211    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5212    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5213          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5214    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5215    {
5216       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5217       return RFAILED;
5218    }
5219
5220    elementCnt = 1; //ODU_VALUE_ONE;
5221    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5222    schReqList->list.count = elementCnt;
5223    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5224
5225    schReqList->list.array = NULLP;
5226    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5227    if(!schReqList->list.array)
5228    {
5229       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5230       return RFAILED;
5231    }
5232
5233    for(idx=0;idx<schReqList->list.count; idx++)
5234    {
5235       schReqList->list.array[idx] = NULLP;
5236       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5237       if(!schReqList->list.array[idx])
5238       {
5239          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5240          return RFAILED;
5241       }
5242    }
5243
5244    idx = 0;
5245    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5246
5247    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5248    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5249    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5250    {
5251       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5252       return RFAILED;
5253    }
5254    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5255    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5256    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5257
5258    return ROK;
5259 }
5260 /*******************************************************************
5261  *
5262  * @brief Builds Mac cell group config
5263  *
5264  * @details
5265  *
5266  *    Function : BuildMacCellGrpCfg
5267  *
5268  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5269  *
5270  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5271  *
5272  * @return ROK     - success
5273  *         RFAILED - failure
5274  *
5275  * ****************************************************************/
5276 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5277 {
5278    macCellGrpCfg->drx_Config = NULLP;
5279    macCellGrpCfg->schedulingRequestConfig = NULLP;
5280    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5281    if(!macCellGrpCfg->schedulingRequestConfig)
5282    {
5283       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5284       return RFAILED;
5285    }
5286
5287    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5288    {
5289       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5290       return RFAILED;
5291    }
5292
5293    macCellGrpCfg->bsr_Config = NULLP;
5294    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5295    if(!macCellGrpCfg->bsr_Config)
5296    {
5297       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5298       return RFAILED;
5299    }
5300
5301    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5302    {
5303       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5304       return RFAILED;
5305    }
5306
5307    macCellGrpCfg->tag_Config = NULLP;
5308    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5309    if(!macCellGrpCfg->tag_Config)
5310    {
5311       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5312       return RFAILED;
5313    }
5314
5315    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5316    {
5317       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5318       return RFAILED;
5319    }
5320
5321    macCellGrpCfg->phr_Config = NULLP;
5322    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5323    if(!macCellGrpCfg->phr_Config)
5324    {
5325       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5326       return RFAILED;
5327    }
5328
5329    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5330    {
5331       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5332       return RFAILED;
5333    }
5334
5335    macCellGrpCfg->skipUplinkTxDynamic = false;
5336    macCellGrpCfg->ext1 = NULLP;
5337
5338    return ROK;
5339 }
5340 /*******************************************************************
5341  *
5342  * @brief Frees memeory allocated for SearchSpcToAddModList
5343  *
5344  * @details
5345  *
5346  *    Function : FreeSearchSpcToAddModList
5347  *
5348  *    Functionality: Deallocating memory of SearchSpcToAddModList
5349  *
5350  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5351  *
5352  * @return void
5353  *
5354  4221 * ****************************************************************/
5355 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5356 {
5357    uint8_t idx1=0;
5358    uint8_t idx2=0;
5359    struct  SearchSpace *searchSpc=NULLP;
5360
5361    if(searchSpcList->list.array)
5362    {
5363       if(searchSpcList->list.array[idx2])
5364       {
5365          searchSpc = searchSpcList->list.array[idx2];
5366          if(searchSpc->controlResourceSetId)
5367          {
5368             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5369             {
5370                if(searchSpc->monitoringSymbolsWithinSlot)
5371                {
5372                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5373                   {
5374                      if(searchSpc->nrofCandidates)
5375                      {
5376                         if(searchSpc->searchSpaceType)
5377                         {
5378                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5379                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5380                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5381                                     SearchSpace__searchSpaceType));
5382                         }
5383                         CU_FREE(searchSpc->nrofCandidates,
5384                               sizeof(struct SearchSpace__nrofCandidates));
5385                      }
5386                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5387                            searchSpc->monitoringSymbolsWithinSlot->size);
5388                   }
5389                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5390                         sizeof(BIT_STRING_t));
5391                }
5392                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5393                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5394             }
5395             CU_FREE(searchSpc->controlResourceSetId,
5396                   sizeof(ControlResourceSetId_t));
5397          }
5398       }
5399       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5400       {
5401          CU_FREE(searchSpcList->list.array[idx1],
5402                sizeof(struct SearchSpace));
5403       }
5404       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5405    }
5406 }
5407 /*******************************************************************
5408  *
5409  * @brief Frees memory allocated for PdschTimeDomAllocList
5410  *
5411  * @details
5412  *
5413  *    Function : FreePdschTimeDomAllocList
5414  *
5415  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5416  *
5417  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5418  *
5419  * @return void
5420  *
5421  4221 * ****************************************************************/
5422 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5423 {
5424    uint8_t idx1=0;
5425
5426    if(timeDomAllocList->choice.setup)
5427    {
5428       if(timeDomAllocList->choice.setup->list.array)
5429       {
5430          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5431          {
5432             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5433                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5434          }
5435          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5436                timeDomAllocList->choice.setup->list.size);
5437       }
5438       CU_FREE(timeDomAllocList->choice.setup,\
5439             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5440    }
5441 }
5442 /*******************************************************************
5443  *
5444  * @brief Frees memory allocated for PuschTimeDomAllocList
5445  *
5446  *@details
5447  *
5448  *    Function : FreePuschTimeDomAllocList
5449  *
5450  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5451  *
5452  * @params[in] PUSCH_Config_t *puschCfg
5453  *
5454  * @return void
5455  *
5456  ***********************************************************************/
5457 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5458 {
5459    uint8_t idx1=0;
5460    uint8_t idx2=0;
5461    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5462
5463    if(puschCfg->pusch_TimeDomainAllocationList)
5464    {
5465       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5466       if(timeDomAllocList_t->choice.setup)
5467       {
5468          if(timeDomAllocList_t->choice.setup->list.array)
5469          {
5470             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5471             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5472             {
5473                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5474                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5475             }
5476             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5477                   timeDomAllocList_t->choice.setup->list.size);
5478          }
5479          CU_FREE(timeDomAllocList_t->choice.setup, \
5480                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5481       }
5482       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5483       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5484             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5485    }
5486
5487 }
5488
5489 /*******************************************************************
5490  *
5491  * @brief Frees memory allocated for Dedicated PUCCH config
5492  *
5493  * @details
5494  *
5495  *    Function : FreeBWPUlDedPucchCfg
5496  *
5497  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5498  *
5499  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5500  *
5501  * @return void
5502  *
5503  * ****************************************************************/
5504 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5505 {
5506    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5507    PUCCH_Config_t *pucchCfg = NULLP;
5508    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5509    PUCCH_Resource_t *rsrc = NULLP;
5510
5511    if(ulBwpPucchCfg)
5512    {
5513       if(ulBwpPucchCfg->choice.setup)
5514       {
5515          pucchCfg = ulBwpPucchCfg->choice.setup;
5516
5517          //Free resource set list
5518          if(pucchCfg->resourceSetToAddModList)
5519          {
5520             if(pucchCfg->resourceSetToAddModList->list.array)
5521             {
5522                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5523                {
5524                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5525                   if(rsrcSet->resourceList.list.array)
5526                   {
5527                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5528                      {
5529                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5530                      }
5531                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5532                   }
5533                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5534                }
5535                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5536             }
5537             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5538          }
5539
5540          //Free resource list
5541          if(pucchCfg->resourceToAddModList)
5542          {
5543             if(pucchCfg->resourceToAddModList->list.array)
5544             {
5545                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5546                {
5547                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5548                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5549                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5550                }
5551                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5552             }
5553             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5554          }
5555
5556          //PUCCH Format 1
5557          if(pucchCfg->format1)
5558          {
5559             if(pucchCfg->format1->choice.setup)
5560             {
5561                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5562                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5563             }
5564             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5565          }
5566
5567          //DL DATA TO UL ACK
5568          if(pucchCfg->dl_DataToUL_ACK)
5569          {
5570             if(pucchCfg->dl_DataToUL_ACK->list.array)
5571             {
5572                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5573                {
5574                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5575                }
5576                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5577             }
5578             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5579          }
5580
5581          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5582       }
5583       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5584    }
5585 }
5586
5587 /*******************************************************************
5588  *
5589  * @brief Frees memory allocated for InitialUlBWP
5590  *
5591  * @details
5592  *
5593  *    Function : FreeInitialUlBWP
5594  *
5595  *    Functionality: Deallocating memory of InitialUlBWP
5596  *
5597  * @params[in] BWP_UplinkDedicated_t *ulBwp
5598  *
5599  * @return void
5600  *
5601  * ****************************************************************/
5602 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5603 {
5604    uint8_t  rSetIdx, rsrcIdx;
5605    SRS_Config_t   *srsCfg = NULLP;
5606    PUSCH_Config_t *puschCfg = NULLP;
5607    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5608    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5609    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5610    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5611
5612    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5613
5614    if(ulBwp->pusch_Config)
5615    {
5616       if(ulBwp->pusch_Config->choice.setup)
5617       {
5618          puschCfg=ulBwp->pusch_Config->choice.setup;
5619          if(puschCfg->dataScramblingIdentityPUSCH)
5620          {
5621             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5622             {
5623                FreePuschTimeDomAllocList(puschCfg);
5624                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5625                if(dmrsUlCfg->choice.setup)
5626                {
5627                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5628                   {
5629                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5630                      {
5631                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5632                               sizeof(long));
5633                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5634                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5635                      }
5636                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5637                            sizeof(long));
5638                   }
5639                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5640                }
5641                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5642                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5643             }
5644             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5645          }
5646          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5647       }
5648       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5649
5650       /* Free SRS-Config */
5651       if(ulBwp->srs_Config)
5652       {
5653          if(ulBwp->srs_Config->choice.setup)
5654          {
5655             srsCfg = ulBwp->srs_Config->choice.setup;
5656
5657             /* Free Resource Set to add/mod list */
5658             if(srsCfg->srs_ResourceSetToAddModList)
5659             {
5660                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5661                if(rsrcSetList->list.array)
5662                {
5663                   rSetIdx = 0;
5664
5665                   /* Free SRS resource Id list in this SRS resource set */
5666                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5667                   {
5668                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5669
5670                      if(rsrcIdList->list.array)
5671                      {
5672                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5673                         {
5674                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5675                         }
5676                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5677                      }
5678                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5679                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5680                   }
5681
5682                   /* Free resource type info for this SRS resource set */
5683                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5684                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5685
5686                   /* Free memory for each resource set */
5687                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5688                   {
5689                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5690                   }
5691                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5692                }
5693                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5694                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5695             }
5696
5697             /* Free resource to add/modd list */
5698             if(srsCfg->srs_ResourceToAddModList)
5699             {
5700                resourceList = srsCfg->srs_ResourceToAddModList;
5701                if(resourceList->list.array)
5702                {
5703                   rsrcIdx = 0;
5704                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5705                         sizeof(struct SRS_Resource__transmissionComb__n2));
5706                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5707                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5708
5709                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5710                   {
5711                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5712                   }
5713                   CU_FREE(resourceList->list.array, resourceList->list.size);
5714                }
5715                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5716                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5717             }
5718
5719             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5720          }
5721          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5722       }
5723    }
5724 }
5725 /*******************************************************************
5726  *
5727  * @brief Frees memory allocated for initialUplinkBWP
5728  *
5729  * @details
5730  *
5731  *    Function : FreeinitialUplinkBWP
5732  *
5733  *    Functionality: Deallocating memory of initialUplinkBWP
5734  *
5735  * @params[in] UplinkConfig_t *ulCfg
5736  *
5737  * @return void
5738  *
5739  *
5740  * ****************************************************************/
5741 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5742 {
5743    BWP_UplinkDedicated_t *ulBwp=NULLP;
5744    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5745
5746    if(ulCfg->initialUplinkBWP)
5747    {
5748       ulBwp=ulCfg->initialUplinkBWP;
5749       if(ulCfg->firstActiveUplinkBWP_Id)
5750       {
5751          if(ulCfg->pusch_ServingCellConfig)
5752          {
5753             puschCfg=ulCfg->pusch_ServingCellConfig;
5754             if(puschCfg->choice.setup)
5755             {
5756                if(puschCfg->choice.setup->ext1)
5757                {
5758                   CU_FREE(puschCfg->choice.setup->ext1->\
5759                         processingType2Enabled,sizeof(BOOLEAN_t));
5760                   CU_FREE(puschCfg->choice.setup->ext1->\
5761                         maxMIMO_Layers,sizeof(long));
5762                   CU_FREE(puschCfg->choice.setup->ext1, \
5763                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5764                }
5765                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5766             }
5767             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5768          }
5769          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5770       }
5771       FreeInitialUlBWP(ulBwp);
5772       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5773    }
5774 }
5775 /*******************************************************************
5776  *
5777  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5778  *
5779  * @details
5780  *
5781  *    Function : FreeBWPDlDedPdschCfg
5782  *
5783  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5784  *
5785  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5786  *
5787  * @return void
5788  *
5789  *
5790  * ****************************************************************/
5791 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5792 {
5793    struct PDSCH_Config *pdschCfg=NULLP;
5794    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5795    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5796    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5797
5798    if(dlBwp->pdsch_Config->choice.setup)
5799    {
5800       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5801       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5802       {
5803          if(pdschCfg->pdsch_TimeDomainAllocationList)
5804          {
5805             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5806             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5807             {
5808                prbBndlType=&pdschCfg->prb_BundlingType;
5809                CU_FREE(prbBndlType->choice.staticBundling,\
5810                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5811                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5812             }
5813             FreePdschTimeDomAllocList(timeDomAllocList);
5814             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5815                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5816          }
5817          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5818          if(dmrsDlCfg->choice.setup)
5819          {
5820             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5821                   sizeof(long));
5822             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5823          }
5824          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5825                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5826       }
5827       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5828    }
5829 }
5830 /*******************************************************************
5831  *
5832  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5833  *
5834  * @details
5835  *
5836  *    Function : FreeBWPDlDedPdcchCfg
5837  *
5838  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5839  *
5840  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5841  *
5842  * @return void
5843  *
5844  *
5845  * ****************************************************************/
5846 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5847 {
5848    uint8_t idx1=0;
5849    uint8_t idx2=0;
5850    struct PDCCH_Config *pdcchCfg=NULLP;
5851    struct ControlResourceSet *controlRSet=NULLP;
5852    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5853
5854    if(dlBwp->pdcch_Config->choice.setup)
5855    {
5856       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5857       if(pdcchCfg->controlResourceSetToAddModList)
5858       {
5859          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5860          if(controlRSetList->list.array)
5861          {
5862             controlRSet = controlRSetList->list.array[idx2];
5863             if(controlRSet)
5864             {
5865                if(controlRSet->frequencyDomainResources.buf)
5866                {
5867                   if(controlRSet->pdcch_DMRS_ScramblingID)
5868                   {
5869                      if(pdcchCfg->searchSpacesToAddModList)
5870                      {
5871                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5872                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5873                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5874                      }
5875                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5876                   }
5877                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5878                         controlRSet->frequencyDomainResources.size);
5879                }
5880             }
5881             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5882             {
5883                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5884             }
5885             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5886          }
5887          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5888                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5889       }
5890       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5891    }
5892 }
5893 /*******************************************************************
5894  *
5895  * @brief Builds RLC Config
5896  *
5897  * @details
5898  *
5899  *    Function : BuildRlcConfig
5900  *
5901  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5902  *
5903  * @params[in] RLC_Config *rlcConfig
5904  *
5905  * @return ROK     - success
5906  *         RFAILED - failure
5907  *
5908  * ****************************************************************/
5909 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
5910 {
5911    rlcConfig->present = rlcLcCfgDb.rlcMode;
5912
5913    switch(rlcConfig->present)
5914    {
5915       case RLC_Config_PR_am:
5916          {
5917             rlcConfig->choice.am = NULLP;
5918             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5919             if(!rlcConfig->choice.am)
5920             {
5921                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5922                return RFAILED;
5923             }
5924
5925             /* UL */
5926             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5927             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5928             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5929             {
5930                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5931                return RFAILED;
5932             }
5933             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
5934             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
5935             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
5936             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
5937             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
5938
5939             /* DL */
5940             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5941             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5942             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5943             {
5944                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5945                return RFAILED;
5946             }
5947             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
5948             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
5949             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
5950
5951             break;
5952          }
5953
5954       case RLC_Config_PR_um_Bi_Directional:
5955          {
5956             rlcConfig->choice.um_Bi_Directional = NULLP;
5957             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
5958             if(!rlcConfig->choice.um_Bi_Directional)
5959             {
5960                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5961                return RFAILED;
5962             }
5963
5964             /* UL */
5965             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
5966             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5967             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
5968             {
5969                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5970                return RFAILED;
5971             }
5972             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
5973
5974             /* DL */
5975             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
5976             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5977             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
5978             {
5979                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5980                return RFAILED;
5981             }
5982             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
5983             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
5984             break;
5985          }
5986    }
5987    return ROK;
5988 }
5989
5990 /*******************************************************************
5991  *
5992  * @brief Builds MAC LC Config
5993  *
5994  * @details
5995  *
5996  *    Function : BuildMacLCConfig
5997  *
5998  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5999  *
6000  * @params[in] struct LogicalChannelConfig macLcConfig
6001  *
6002  * @return ROK     - success
6003  *         RFAILED - failure
6004  *
6005  * ****************************************************************/
6006 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6007 {
6008
6009    macLcConfig->ul_SpecificParameters = NULLP;
6010    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6011    if(!macLcConfig->ul_SpecificParameters)
6012    {
6013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6014       return RFAILED;
6015    }
6016
6017    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6018    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6019    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6020    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6021    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6022    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6023    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6024
6025    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6026    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6027    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6028    {
6029       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6030       return RFAILED;
6031    }
6032    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6033
6034    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6035    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6036    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6037    {
6038       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6039       return RFAILED;
6040    }
6041    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6042
6043    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6044    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6045    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6046
6047    return ROK;
6048 }
6049 /*******************************************************************
6050  *
6051  * @brief Builds RLC Bearer to Add/Mod list
6052  *
6053  * @details
6054  *
6055  *    Function :BuildRlcBearerToAddModList
6056  *
6057  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6058  *
6059  * @params[in] rlc_BearerToAddModList
6060  *
6061  * @return ROK     - success
6062  *         RFAILED - failure
6063  *
6064  * ****************************************************************/
6065 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6066 {
6067    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6068
6069    if(updateAllRbCfg)
6070       elementCnt = ueCb->numSrb + ueCb->numDrb;
6071    else
6072    {
6073       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6074       {
6075          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6076             elementCnt++;
6077       }
6078
6079       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6080       {
6081          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6082             elementCnt++;
6083       }
6084    }
6085
6086    if(!elementCnt)
6087    {
6088       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6089       return ROK;
6090    }
6091    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6092    if(!rlcBearerList)
6093    {
6094       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6095       return RFAILED;
6096    }
6097    rlcBearerList->list.count = elementCnt;
6098    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6099
6100    rlcBearerList->list.array = NULLP;
6101    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6102    if(!rlcBearerList->list.array)
6103    {
6104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6105       return RFAILED;
6106    }
6107
6108    for(idx=0; idx<rlcBearerList->list.count; idx++)
6109    {
6110       rlcBearerList->list.array[idx] = NULLP;
6111       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6112       if(!rlcBearerList->list.array[idx])
6113       {
6114          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6115          return RFAILED;
6116       }
6117    }
6118
6119    idx = 0;
6120
6121    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6122    {
6123       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6124          continue;
6125
6126       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6127
6128       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6129       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6130       {
6131          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6132          return RFAILED;
6133       }
6134
6135       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6136       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6137
6138       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6139       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6140       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6141       if(!rlcBearerList->list.array[idx]->rlc_Config)
6142       {
6143          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6144          return RFAILED;
6145       }
6146
6147       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6148       {
6149          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6150          return RFAILED;
6151       }
6152
6153       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6154       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6155       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6156       {
6157          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6158          return RFAILED;
6159       }
6160
6161       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6162       {
6163          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6164          return RFAILED;
6165       }
6166       idx++;
6167    }
6168
6169    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6170    {
6171       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6172          continue;
6173
6174       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6175
6176       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6177       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6178       {
6179          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6180          return RFAILED;
6181       }
6182
6183       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6184       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6185
6186       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6187       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6188       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6189       if(!rlcBearerList->list.array[idx]->rlc_Config)
6190       {
6191          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6192          return RFAILED;
6193       }
6194
6195       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6196       {
6197          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6198          return RFAILED;
6199       }
6200
6201       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6202       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6203       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6204       {
6205          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6206          return RFAILED;
6207       }
6208
6209       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6210       {
6211          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6212          return RFAILED;
6213       }
6214       idx++;
6215    }
6216    return ROK;
6217 }
6218
6219 /*******************************************************************
6220  *
6221  * @brief Free memory allocated for CellGroupConfig
6222  *
6223  * @details
6224  *
6225  *    Function : FreeMemCellGrpCfg
6226  *
6227  *    Functionality: Deallocating memory of CellGroupConfig
6228  *
6229  * @params[in] pointer to CellGroupConfigRrc_t
6230  *
6231  * @return ROK     - success
6232  *         RFAILED - failure
6233  *
6234  ******************************************************************/
6235 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6236 {
6237    uint8_t idx=0;
6238    SpCellConfig_t *spCellCfg=NULLP;
6239    ServingCellConfig_t *srvCellCfg=NULLP;
6240    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6241    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6242    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6243    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6244    struct RLC_Config *rlcConfig=NULLP;
6245    struct LogicalChannelConfig *macLcConfig=NULLP;
6246    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6247    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6248    struct TAG_Config *tagConfig=NULLP;
6249    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6250    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6251    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6252
6253    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6254    if(rlcBearerList)
6255    {
6256       if(rlcBearerList->list.array)
6257       {
6258          for(idx=0; idx<rlcBearerList->list.count; idx++)
6259          {
6260             if(rlcBearerList->list.array[idx])
6261             {
6262                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6263                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6264                if(rlcConfig)
6265                {
6266                   if(rlcConfig->choice.am)
6267                   {
6268                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6269                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6270                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6271                   }
6272                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6273                }
6274                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6275                if(macLcConfig)
6276                {
6277                   if(macLcConfig->ul_SpecificParameters)
6278                   {
6279                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6280                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6281                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6282                   }
6283                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6284                }
6285                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6286             }
6287          }
6288          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6289       }
6290       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6291    }
6292
6293    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6294    if(macCellGrpCfg)
6295    {
6296       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6297       if(schedulingRequestConfig)
6298       {
6299          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6300          if(schReqList)
6301          {
6302             if(schReqList->list.array)
6303             {
6304                for(idx=0;idx<schReqList->list.count; idx++)
6305                {
6306                   if(schReqList->list.array[idx])
6307                   {
6308                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6309                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6310                   }
6311                }
6312                CU_FREE(schReqList->list.array, schReqList->list.size);
6313             }
6314             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6315                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6316             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6317       }
6318       if(macCellGrpCfg->bsr_Config)
6319       {
6320          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6321       }
6322       tagConfig = macCellGrpCfg->tag_Config;
6323       if(tagConfig)
6324       {
6325          tagList = tagConfig->tag_ToAddModList;
6326          if(tagList)
6327          {
6328             if(tagList->list.array)
6329             {
6330                for(idx=0; idx<tagList->list.count; idx++)
6331                {
6332                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6333                }
6334                CU_FREE(tagList->list.array, tagList->list.size);
6335             }
6336             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6337          }
6338          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6339       }
6340
6341       phrConfig = macCellGrpCfg->phr_Config;
6342       if(phrConfig)
6343       {
6344          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6345          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6346       }
6347
6348       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6349    }
6350
6351    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6352    if(phyCellGrpCfg)
6353    {
6354       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6355       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6356    }
6357
6358    spCellCfg = cellGrpCfg->spCellConfig;
6359    if(spCellCfg)
6360    {
6361       if(spCellCfg->servCellIndex)
6362       {
6363          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6364          {
6365             if(spCellCfg->spCellConfigDedicated)
6366             {
6367                srvCellCfg = spCellCfg->spCellConfigDedicated;
6368                if(srvCellCfg->initialDownlinkBWP)
6369                {
6370                   dlBwp = srvCellCfg->initialDownlinkBWP;
6371                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6372                   {
6373                      if(srvCellCfg->defaultDownlinkBWP_Id)
6374                      {
6375                         if(srvCellCfg->uplinkConfig)
6376                         {
6377                            if(srvCellCfg->pdsch_ServingCellConfig)
6378                            {
6379                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6380                               if(pdschCfg->choice.setup)
6381                               {
6382                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6383                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6384                               }
6385                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6386                                        ServingCellConfig__pdsch_ServingCellConfig));
6387                            }
6388                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6389                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6390                         }
6391                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6392                      }
6393                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6394                   }
6395                   if(dlBwp->pdcch_Config)
6396                   {
6397                      if(dlBwp->pdsch_Config)
6398                      {
6399                         FreeBWPDlDedPdschCfg(dlBwp);
6400                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6401                      }
6402                      FreeBWPDlDedPdcchCfg(dlBwp);
6403                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6404                   }
6405                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6406                }
6407                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6408             }
6409             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6410          }
6411          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6412       }
6413       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6414    }
6415    return ROK;
6416 }
6417
6418 /*******************************************************************
6419  *
6420  * @brief Fills CellGroupConfig
6421  *
6422  * @details
6423  *
6424  *    Function : fillCellGrpCfg
6425  *
6426  *    Functionality: Fills CellGroupConfig
6427  *
6428  * @params[in] pointer to CellGroupConfigRrc_t
6429  *
6430  * @return ROK     - success
6431  *         RFAILED - failure
6432  *
6433  ******************************************************************/
6434
6435 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6436 {
6437    uint8_t               ret = RFAILED;
6438    CellGroupConfigRrc_t  cellGrpCfg;
6439    asn_enc_rval_t        encRetVal;
6440
6441    while(true)
6442    {
6443       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6444
6445       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6446
6447       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6448       {
6449          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6450          break;
6451       }
6452
6453       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6454       cellGrpCfg.mac_CellGroupConfig = NULLP;
6455       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6456       if(!cellGrpCfg.mac_CellGroupConfig)
6457       {
6458          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6459          break;
6460       }
6461       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6462       {
6463          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6464          break;
6465       }
6466
6467       cellGrpCfg.physicalCellGroupConfig = NULLP;
6468       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6469       if(!cellGrpCfg.physicalCellGroupConfig)
6470       {
6471          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6472          break;
6473       }
6474       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6475       {
6476          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6477          break;
6478       }
6479
6480       cellGrpCfg.spCellConfig = NULLP;
6481       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6482       if(!cellGrpCfg.spCellConfig)
6483       {
6484          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6485          break;
6486       }
6487       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6488       {
6489          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6490          break;
6491       }
6492
6493       cellGrpCfg.sCellToAddModList = NULLP;
6494       cellGrpCfg.sCellToReleaseList = NULLP;
6495       cellGrpCfg.ext1 = NULLP;
6496
6497       /* encode cellGrpCfg into duToCuRrcContainer */
6498       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6499       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6500       encBufSize = 0;
6501       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6502       /* Encode results */
6503       if(encRetVal.encoded == ENCODE_FAIL)
6504       {
6505          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6506                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6507          break;
6508       }
6509       else
6510       {
6511          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6512          for(int i=0; i< encBufSize; i++)
6513          {
6514             DU_LOG("%x",encBuf[i]);
6515          }
6516       }
6517
6518       cellGrp->size = encBufSize;
6519       CU_ALLOC(cellGrp->buf, cellGrp->size);
6520       if(!cellGrp->buf)
6521       {
6522          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6523          break;
6524       }
6525       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6526       ret = ROK;
6527       break;
6528    }
6529    FreeMemCellGrpCfg(&cellGrpCfg);
6530    return ret;
6531 }
6532
6533 /*******************************************************************
6534  *
6535  * @brief Free UE Capability RAT container
6536  *
6537  * @details
6538  *
6539  *    Function : freeUeCapRatCont
6540  *
6541  *    Functionality:
6542  *       Free UE Capability RAT conatiner
6543  *
6544  * @params[in]
6545  * @return ROK     - success
6546  *         RFAILED - failure
6547  *
6548  * ****************************************************************/
6549 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6550 {
6551    uint8_t idx;
6552    FeatureSets_t *featureSets;
6553
6554    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6555    {
6556       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6557       {
6558          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6559             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6560       }
6561       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6562    }
6563
6564    if(ueNrCap->featureSets)
6565    {
6566       featureSets = ueNrCap->featureSets;
6567       if(featureSets->featureSetsDownlinkPerCC)
6568       {
6569          if(featureSets->featureSetsDownlinkPerCC->list.array)
6570          {
6571             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6572             {
6573                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6574                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6575                         sizeof(ModulationOrder_t));
6576                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6577             }
6578             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6579          }
6580          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6581       }
6582
6583       if(featureSets->featureSetsUplinkPerCC)
6584       {
6585          if(featureSets->featureSetsUplinkPerCC->list.array)
6586          {
6587             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6588             {
6589                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6590                {
6591                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6592                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6593                          sizeof(ModulationOrder_t));
6594                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6595                }
6596             }
6597             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6598          }
6599          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6600       }
6601       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6602    }
6603 }
6604
6605 /*******************************************************************
6606  *
6607  * @brief Free UE capability RAT container list
6608  *
6609  * @details
6610  *
6611  *    Function : freeUeCapRatContList
6612  *
6613  *    Functionality: Free UE capability RAT container list
6614  *
6615  * @params[in]
6616  * @return ROK     - success
6617  *         RFAILED - failure
6618  *
6619  * ****************************************************************/
6620 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6621 {
6622    uint8_t idx;
6623    if(ueCapablityList->list.array)
6624    {
6625       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6626       {
6627          if(ueCapablityList->list.array[idx])
6628             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6629       }
6630       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6631    }
6632 }
6633
6634 /*******************************************************************
6635  *
6636  * @brief Free Handover preparation information
6637  *
6638  * @details
6639  *
6640  *    Function : freeHOPreparationInfo
6641  *
6642  *    Functionality: Free Handover preparation information
6643  *
6644  * @params[in]
6645  * @return ROK     - success
6646  *         RFAILED - failure
6647  *
6648  * ****************************************************************/
6649 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6650 {
6651    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6652
6653    if(hoPrep->criticalExtensions.choice.c1)
6654    {
6655       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6656       {
6657          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6658          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6659          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6660                sizeof(HandoverPreparationInformationRrc_IEs_t));
6661       }
6662       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6663    }
6664 }
6665
6666 /*******************************************************************
6667  *
6668  * @brief Fill feature sets
6669  *
6670  * @details
6671  *
6672  *    Function : fillFeatureSets
6673  *
6674  *    Functionality: Fill feature sets
6675  *
6676  * @params[in]
6677  * @return ROK     - success
6678  *         RFAILED - failure
6679  *
6680  * ****************************************************************/
6681 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6682 {
6683    uint8_t idx, elementCnt;
6684
6685    featureSets->featureSetsDownlink = NULLP;
6686    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6687    if(!featureSets->featureSetsDownlinkPerCC)
6688    {
6689       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6690       return RFAILED;
6691    }
6692
6693    elementCnt = 1;
6694    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6695    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6696    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6697    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6698    {
6699       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6700       return RFAILED;
6701    }
6702
6703    for(idx = 0; idx < elementCnt; idx++)
6704    {
6705       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6706       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6707       {
6708          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6709          return RFAILED;
6710       }
6711    }
6712
6713    idx = 0;
6714    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6715    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6716    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6717    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6718    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6719
6720    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6721    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6722    {
6723       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6724       return RFAILED;
6725    }
6726    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6727
6728    featureSets->featureSetsUplink = NULLP;
6729    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6730    if(!featureSets->featureSetsUplinkPerCC)
6731    {
6732       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6733       return RFAILED;
6734    }
6735
6736    elementCnt = 1;
6737    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6738    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6739    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6740    if(!featureSets->featureSetsUplinkPerCC->list.array)
6741    {
6742       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6743       return RFAILED;
6744    }
6745
6746    for(idx = 0; idx < elementCnt; idx++)
6747    {
6748       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6749       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6750       {
6751          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6752          return RFAILED;
6753       }
6754    }
6755
6756    idx = 0;
6757    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6758    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6759    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6760    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6761    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6762    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6763
6764    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6765    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6766    {
6767       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6768       return RFAILED;
6769    }
6770    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6771
6772    return ROK;
6773 }
6774
6775 /*******************************************************************
6776  *
6777  * @brief Fill UE capability RAT container
6778  *
6779  * @details
6780  *
6781  *    Function : fillUeCapRatCont
6782  *
6783  *    Functionality: Fill UE capability RAT container
6784  *
6785  * @params[in] UE Capability RAT container buffer
6786  * @return ROK     - success
6787  *         RFAILED - failure
6788  *
6789  * ****************************************************************/
6790 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6791 {
6792    uint8_t             ret = ROK;
6793    uint8_t             idx, elementCnt;
6794    asn_enc_rval_t      encRetVal;
6795    UE_NR_Capability_t  ueNrCap;
6796
6797    while(true)
6798    {
6799       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6800
6801       /* Filling PDCP parameters */
6802       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6803       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6804       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6805       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6806       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6807       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6808       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6809       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6810       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6811       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6812       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6813       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6814       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6815       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6816       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6817       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6818       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6819
6820       ueNrCap.rlc_Parameters = NULLP;
6821       ueNrCap.mac_Parameters = NULLP;
6822
6823       /* Filling PHY parameters */
6824       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6825       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6826       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6827       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6828       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6829
6830       /* Filling RF parameters */
6831       elementCnt = 1;
6832       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6833       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6834       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6835       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6836       {
6837          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6838          ret = RFAILED;
6839          break;
6840       }
6841
6842       for(idx = 0; idx < elementCnt; idx++)
6843       {
6844          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6845          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6846          {
6847             ret = RFAILED;
6848             break;
6849          }
6850       }
6851       if(ret == RFAILED)
6852          break;
6853
6854       idx = 0;
6855       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6856       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6857       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6858
6859       ueNrCap.measAndMobParameters = NULLP;
6860       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6861       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6862       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6863       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6864       ueNrCap.featureSets = NULLP;
6865
6866       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6867       if(!ueNrCap.featureSets)
6868       {
6869          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6870          ret = RFAILED;
6871          break;
6872       }
6873
6874       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6875       {
6876          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6877          ret = RFAILED;
6878          break;
6879       }
6880
6881       ueNrCap.featureSetCombinations = NULLP;
6882       ueNrCap.lateNonCriticalExtension = NULLP;
6883       ueNrCap.nonCriticalExtension = NULLP;
6884
6885       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6886       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6887       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6888       encBufSize = 0;
6889       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6890
6891       /* Encode results */
6892       if(encRetVal.encoded == ENCODE_FAIL)
6893       {
6894          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6895             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6896          break;
6897       }
6898       else
6899       {
6900          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6901          for(int i=0; i< encBufSize; i++)
6902          {
6903             DU_LOG("%x",encBuf[i]);
6904          }
6905       }
6906
6907       ueCapRatContBuf->size = encBufSize;
6908       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6909       if(!ueCapRatContBuf->buf)
6910       {
6911          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6912          break;
6913       }
6914       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6915       ret = ROK;
6916       break;
6917    }
6918    freeUeCapRatCont(&ueNrCap);
6919    return ROK;
6920 }
6921
6922 /*******************************************************************
6923  *
6924  * @brief Fill UE Capability RAT container list
6925  *
6926  * @details
6927  *
6928  *    Function : fillUeCapRatContList
6929  *
6930  *    Functionality: Fill UE Capability RAT container list
6931
6932  *
6933  * @params[in] UE capability RAT container list
6934  * @return ROK     - success
6935  *         RFAILED - failure
6936  *
6937  * ****************************************************************/
6938 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
6939 {
6940     uint8_t          ret = RFAILED;
6941     uint8_t          idx, elementCnt;
6942
6943     while(true)
6944     {
6945        elementCnt = 1;
6946        ueCapablityList->list.count = elementCnt;
6947        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6948
6949        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
6950        if(!ueCapablityList->list.array)
6951        {
6952           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6953           ret = RFAILED;
6954           break;
6955        }
6956
6957        for(idx=0; idx<elementCnt; idx++)
6958        {
6959           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6960           if(ueCapablityList->list.array[idx] == NULLP)
6961           {
6962              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6963              ret = RFAILED;
6964              break;
6965           }
6966        }
6967        idx = 0;
6968        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
6969        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
6970        {
6971           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
6972           ret = RFAILED;
6973           break;
6974        }
6975
6976        ret = ROK;
6977        break;
6978     }
6979     return ret;
6980 }
6981
6982 /*******************************************************************
6983  *
6984  * @brief Fill UE Capability RAT container list octet string
6985  *
6986  * @details
6987  *
6988  *    Function : fillUeCapRatContListBuf
6989  *
6990  *    Functionality: Fill UE Capability RAT container list octet string
6991
6992  *
6993  * @params[in] UE capability RAT container list buffer
6994  * @return ROK     - success
6995  *         RFAILED - failure
6996  *
6997  * ****************************************************************/
6998 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6999 {
7000    uint8_t          ret = RFAILED;
7001    asn_enc_rval_t   encRetVal;
7002    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7003
7004    while(true)
7005    {
7006       ret = fillUeCapRatContList(&ueCapablityList);
7007       if(ret != ROK)
7008       {
7009          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7010          break;
7011       }
7012
7013       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7014       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7015       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7016       encBufSize = 0;
7017       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7018             &ueCapablityList, PrepFinalEncBuf, encBuf);
7019
7020       /* Encode results */
7021       if(encRetVal.encoded == ENCODE_FAIL)
7022       {
7023          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7024                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7025          break;
7026       }
7027       else
7028       {
7029          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7030          for(int i=0; i< encBufSize; i++)
7031          {
7032             DU_LOG("%x",encBuf[i]);
7033          }
7034       }
7035
7036       ueCapablityListBuf->size = encBufSize;
7037       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7038       if(!ueCapablityListBuf->buf)
7039       {
7040          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7041          break;
7042       }
7043       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7044       ret = ROK;
7045       break;
7046    }
7047    freeUeCapRatContList(&ueCapablityList);
7048    return ret;
7049 }
7050
7051 /*******************************************************************
7052  *
7053  * @brief Free Measurement Timing Configuration
7054  *
7055  * @details
7056  *
7057  *    Function : freeMeasuementTimingConfig
7058  *
7059  *    Functionality: Free Measurement Timing Configuration
7060  *
7061  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7062  * @return void
7063  *
7064  * ****************************************************************/
7065 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7066 {
7067    uint8_t measCfgIdx;
7068    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7069    MeasTiming_t *measTiming = NULLP;
7070
7071    if(measTimingConfig.criticalExtensions.choice.c1)
7072    {
7073       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7074       {
7075          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7076          if(measTimingCfg->measTiming)
7077          {
7078             if(measTimingCfg->measTiming->list.array)
7079             {
7080                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7081                {
7082                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7083                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7084                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7085                }
7086                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7087             }
7088             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7089          }
7090          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7091       }
7092       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7093    }
7094 }
7095
7096 /*******************************************************************
7097  *
7098  * @brief Fill Measurement Timing Configuration
7099  *
7100  * @details
7101  *
7102  *    Function : fillMeasTimingCfg
7103  *
7104  *    Functionality: Fill Measurement Timing Configuration
7105  *
7106  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7107  * @return ROK     - success
7108  *         RFAILED - failure
7109  *
7110  * ****************************************************************/
7111 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7112 {
7113    uint8_t elementCnt = 0;
7114    uint8_t measCfgIdx = 0;
7115    MeasTiming_t *measTiming;
7116    SSB_MTC_t *smtc;
7117
7118    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7119    if(!measTimingCfg->measTiming)
7120    {
7121       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7122       return RFAILED;
7123    }
7124
7125    elementCnt = 1;
7126    measTimingCfg->measTiming->list.count = elementCnt;
7127    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7128    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7129    if(!measTimingCfg->measTiming->list.array)
7130    {
7131       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7132       return RFAILED;
7133    }
7134
7135    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7136    {
7137       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7138       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7139       {
7140          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7141          return RFAILED;
7142       }
7143    }
7144
7145    measCfgIdx = 0;
7146    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7147    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7148    if(!measTiming->frequencyAndTiming)
7149    {
7150       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7151       return RFAILED;
7152    }
7153
7154    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7155    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7156
7157    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7158    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7159    smtc->periodicityAndOffset.choice.sf20 = 0;
7160    smtc->duration = SSB_MTC__duration_sf1;
7161    return ROK;
7162 }
7163
7164 /*******************************************************************
7165  *
7166  * @brief Fill Measurement Timing Configuration Octet string
7167  *
7168  * @details
7169  *
7170  *    Function : fillMeasConfigBuf
7171  *
7172  *    Functionality: Fill Measurement Timing Configuration Octet string
7173
7174  *
7175  * @params[in] MeasConfig_t *measConfgBuf
7176  * @return ROK     - success
7177  *         RFAILED - failure
7178  *
7179  * ****************************************************************/
7180 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7181 {
7182    uint8_t          ret = RFAILED;
7183    asn_enc_rval_t   encRetVal;
7184    MeasurementTimingConfigurationRrc_t measTimingConfig;
7185
7186    while(true)
7187    {
7188       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7189       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7190       if(!measTimingConfig.criticalExtensions.choice.c1)
7191       {
7192          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7193          return RFAILED;
7194       }
7195       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7196
7197       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7198       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7199       {
7200          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7201          return RFAILED;
7202       }
7203
7204       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7205       if(ret != ROK)
7206       {
7207          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7208          break;
7209       }
7210
7211       /* Encode measurement timing configuration into octet string */
7212       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7213       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7214       encBufSize = 0;
7215       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7216
7217       /* Encode results */
7218       if(encRetVal.encoded == ENCODE_FAIL)
7219       {
7220          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7221                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7222          break;
7223       }
7224       else
7225       {
7226          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7227          for(int i=0; i< encBufSize; i++)
7228          {
7229             DU_LOG("%x",encBuf[i]);
7230          }
7231       }
7232
7233       measTimingConfigBuf->size = encBufSize;
7234       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7235       if(!measTimingConfigBuf->buf)
7236       {
7237          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7238          break;
7239       }
7240       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7241       ret = ROK;
7242       break;
7243    }
7244    freeMeasuementTimingConfig(measTimingConfig);
7245    return ret;
7246 }
7247
7248 /******************************************************************
7249  *
7250  * @brief Free RRC reconfiguration non-critical extension
7251  *
7252  * @details
7253  *
7254  *    Function : freeRrcReconfigNonCriticalExt
7255  *
7256  *    Functionality: Free RRC reconfiguration non-critical extension
7257  *
7258  * @params[in] RRC reconfiguration IE
7259  * @return void
7260  *
7261  * ****************************************************************/
7262 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7263 {
7264    if(rrcRecfg->masterCellGroup)
7265    {
7266       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7267    }
7268 }
7269
7270 /******************************************************************
7271  *
7272  * @brief Free measurement object addmod list
7273  *
7274  * @details
7275  *
7276  *    Function : freeMeasObjToAddModList
7277  *
7278  *    Functionality: Free measurement object add mod list
7279  *
7280  * @params[in] Measurement object add/mod list
7281  * @return void
7282  *
7283  * ****************************************************************/
7284 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7285 {
7286    uint8_t objIdx;
7287    MeasObjectNR_t *measObject;
7288
7289    if(measObjList->list.array)
7290    {
7291       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7292       {
7293          if(measObjList->list.array[objIdx])
7294          {
7295             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7296             {
7297                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7298                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7299                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7300                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7301                if(measObject->absThreshSS_BlocksConsolidation)
7302                {
7303                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7304                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7305                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7306                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7307                }
7308                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7309                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7310                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7311                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7312                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7313             }
7314             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7315          }
7316       }
7317       CU_FREE(measObjList->list.array, measObjList->list.size);
7318    }
7319 }
7320
7321 /******************************************************************
7322  *
7323  * @brief Free report config add mod list
7324  *
7325  * @details
7326  *
7327  *    Function : freeReportCfgToAddModList
7328  *
7329  *    Functionality: Free report config add mod list
7330  *
7331  * @params[in] Report config list
7332  * @return void
7333  *
7334  * ****************************************************************/
7335 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7336 {
7337    uint8_t reportCfgIdx;
7338    ReportConfigToAddMod_t *reportCfg;
7339    ReportConfigNR_t *reportCfgNr;
7340    EventTriggerConfig_t *eventTriggCfg;
7341
7342    if(reportCfgList->list.array)
7343    {
7344       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7345       {
7346          if(reportCfgList->list.array[reportCfgIdx])
7347          {
7348             reportCfg = reportCfgList->list.array[reportCfgIdx];
7349             if(reportCfg->reportConfig.choice.reportConfigNR)
7350             {
7351                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7352                if(reportCfgNr->reportType.choice.eventTriggered)
7353                {
7354                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7355                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7356                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7357                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7358                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7359                }
7360             }
7361          }
7362          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7363       }
7364       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7365    }
7366 }
7367
7368 /******************************************************************
7369  *
7370  * @brief Free measurement id to add mod list
7371  *
7372  * @details
7373  *
7374  *    Function : freeMeasIdToAddModList
7375  *
7376  *    Functionality: Free measurement id to add mod list
7377  *
7378  * @params[in] Measurement id to add mod list
7379  * @return void
7380  *
7381  * ****************************************************************/
7382 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7383 {
7384    uint8_t measIdIdx;
7385    if(measIdList->list.array)
7386    {
7387       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7388       {
7389          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7390       }
7391       CU_FREE(measIdList->list.array, measIdList->list.size);
7392    }
7393 }
7394
7395 /*******************************************************************
7396  *
7397  * @brief Free quantity config
7398  *
7399  * @details
7400  *
7401  *    Function : freeQunatityConfig
7402  *
7403  *    Functionality: Free quantity config
7404  *
7405  * @params[in] Quantity Config
7406  * @return void
7407  *
7408  * ****************************************************************/
7409 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7410 {
7411    uint8_t quanCfgIdx;
7412    QuantityConfigNR_t *quantityCfgNr;
7413
7414    if(quantityCfg->quantityConfigNR_List)
7415    {
7416       if(quantityCfg->quantityConfigNR_List->list.array)
7417       {
7418          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7419          {
7420             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7421             {
7422                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7423                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7424                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7425                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7426                if(quantityCfgNr->quantityConfigRS_Index)
7427                {
7428                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7429                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7430                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7431                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7432                }
7433                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7434             }
7435          }
7436          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7437       }
7438       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7439    }
7440 }
7441
7442 /******************************************************************
7443  *
7444  * @brief Free measurement Config
7445  *
7446  * @details
7447  *
7448  *    Function : freeMeasConfig
7449  *
7450  *    Functionality: Free measurement config
7451  *
7452  * @params[in] Measurement config
7453  * @return void
7454  *
7455  * ****************************************************************/
7456 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7457 {
7458    if(measConfig->measObjectToAddModList)
7459    {
7460       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7461       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7462    }
7463    if(measConfig->reportConfigToAddModList)
7464    {
7465       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7466       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7467    }
7468    if(measConfig->measIdToAddModList)
7469    {
7470       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7471       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7472    }
7473    if(measConfig->s_MeasureConfig)
7474    {
7475       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7476    }
7477    if(measConfig->quantityConfig)
7478    {
7479       freeQuantityConfig(measConfig->quantityConfig);
7480       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7481    }
7482 }
7483 /******************************************************************
7484  *
7485  * @brief Free DRB to AddMod List
7486  *
7487  * @details
7488  *
7489  *    Function : freeDrbToAddModList
7490  *
7491  *    Functionality: Free SRB to AddMod List
7492  *
7493  * @params[in] SBR to add/mod list
7494  * @return void
7495  *
7496  * ****************************************************************/
7497 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7498 {
7499    uint8_t drbIdx;
7500    if(drbToAddList->list.array)
7501    {
7502       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7503       {
7504          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7505          {
7506             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7507             {
7508                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7509                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7510                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7511                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7512             }
7513             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7514             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7515          }
7516          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7517       }
7518       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7519    }
7520 }
7521
7522 /******************************************************************
7523  *
7524  * @brief Free SRB to AddMod List
7525  *
7526  * @details
7527  *
7528  *    Function : freeSrbToAddModList
7529  *
7530  *    Functionality: Free SRB to AddMod List
7531  *
7532  * @params[in] SBR to add/mod list
7533  * @return void
7534  *
7535  * ****************************************************************/
7536 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7537 {
7538    uint8_t srbIdx;
7539    if(srbToAddList->list.array)
7540    {
7541       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7542       {
7543          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7544          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7545          {
7546             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7547             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7548          }
7549
7550          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7551       }
7552       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7553    }
7554 }
7555
7556 /******************************************************************
7557  *
7558  * @brief Free Radio Bearer Config
7559  *
7560  * @details
7561  *
7562  *    Function : fillRadioBearerConfig
7563  *
7564  *    Functionality: Free Radio Bearer config
7565  *
7566  * @params[in] Radio bearer config
7567  * @return void
7568  *
7569  * ****************************************************************/
7570 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7571 {
7572    if(radioBearerConfig->srb_ToAddModList)
7573    {
7574       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7575       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7576    }
7577    if(radioBearerConfig->drb_ToAddModList)
7578    {
7579       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7580       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7581    }
7582 }
7583
7584 /******************************************************************
7585  *
7586  * @brief Free reconfiguration message
7587  *
7588  * @details
7589  *
7590  *    Function : freeRrcReconfig
7591  *
7592  *    Functionality: Free reconfiguration message
7593  *
7594  * @params[in] RRC Reconfiguration message
7595  * @return void
7596  *
7597  * ****************************************************************/
7598 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7599 {
7600    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7601    {
7602       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7603       {
7604          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7605          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7606       }
7607       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7608       {
7609          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7610          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7611       }
7612       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7613       {
7614          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7615          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7616       }
7617       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7618    }
7619 }
7620
7621 /******************************************************************
7622  *
7623  * @brief Fill SRB To Add Mod list
7624  *
7625  * @details
7626  *
7627  *    Function : fillSrbToAddModList
7628  *
7629  *    Functionality: fill SRB to Add Mod list
7630  *
7631  * @params[in] UE control block
7632  *             SRB to Add/Mod list
7633  * @return ROK     - success
7634  *         RFAILED - failure
7635  *
7636  * ****************************************************************/
7637 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7638 {
7639    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7640
7641    if(updateAllRbCfg)
7642       elementCnt = ueCb->numSrb;
7643    else
7644    {
7645       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7646       {
7647          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7648             elementCnt++;
7649       }
7650    }
7651
7652    if(!elementCnt)
7653    {
7654       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7655       return ROK;
7656    }
7657
7658    CU_ALLOC(srbToAddList, sizeof(SRB_ToAddModList_t));
7659    if(!srbToAddList)
7660    {
7661       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
7662       return RFAILED;
7663    }
7664    srbToAddList->list.count = elementCnt;
7665    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7666
7667    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7668    if(!srbToAddList->list.array)
7669    {
7670       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7671       return RFAILED;
7672    }
7673
7674    srbIdx = 0;
7675    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7676    {
7677       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7678          continue;
7679
7680       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7681       if(!srbToAddList->list.array[srbIdx])
7682       {
7683          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7684          return RFAILED;
7685       }
7686
7687       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7688
7689       /* Reestablish PDCP */
7690       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7691       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7692       {
7693          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7694          return RFAILED;
7695       }
7696       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7697
7698       /* PDCP configuration */
7699       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7700       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7701       {
7702          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7703          return RFAILED;
7704       }
7705
7706       /* Reordering timer */
7707       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7708       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7709       {
7710          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7711          return RFAILED;
7712       }
7713       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7714
7715       srbIdx++;
7716    }
7717    return ROK;
7718 }
7719
7720 /******************************************************************
7721  *
7722  * @biief Fill DRBeTo Add Mod list
7723  *
7724  * @details
7725  *
7726  *    Function : fillDrbToAddModList
7727  *
7728  *    Functionality: fill DRB to Add Mod list
7729  *
7730  * @params[in] UE control block
7731  *             DRB to Add/Mod list
7732  * @return ROK     - success
7733  *         RFAILED - failure
7734  *
7735  * ****************************************************************/
7736 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7737 {
7738    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7739
7740    if(updateAllRbCfg)
7741       elementCnt = ueCb->numDrb;
7742    else
7743    {
7744       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7745       {
7746          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7747             elementCnt++;
7748       }
7749    }
7750
7751    if(!elementCnt)
7752    {
7753       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7754       return ROK;
7755    }
7756
7757    /* DRB To Add/Mod List */
7758    CU_ALLOC(drbToAddList, sizeof(DRB_ToAddModList_t));
7759    if(!drbToAddList)
7760    {
7761       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
7762       return RFAILED;
7763    }
7764
7765    drbToAddList->list.count = elementCnt;
7766    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7767
7768    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7769    if(!drbToAddList->list.array)
7770    {
7771       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7772       return RFAILED;
7773    }
7774
7775    drbIdx = 0;
7776    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7777    {
7778       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7779          continue;
7780
7781       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7782       if(!drbToAddList->list.array[drbIdx])
7783       {
7784          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7785          return RFAILED;
7786       }
7787
7788       /* DRB Id */
7789       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7790
7791       /* PDCP Config */
7792       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7793       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7794       {
7795          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7796          return RFAILED;
7797       }
7798
7799       /* PDCP Config -> DRB */
7800       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7801       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7802       {
7803          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7804          return RFAILED;
7805       }
7806
7807       /* DRB -> Discard Timer */
7808       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7809       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
7810       {
7811          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
7812          return RFAILED;
7813       }
7814       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
7815
7816       /* UL PDCP SN length */
7817       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7818       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
7819       {
7820          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
7821          return RFAILED;
7822       }
7823       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
7824
7825       /* DL PDCP SN length */
7826       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7827       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
7828       {
7829          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
7830          return RFAILED;
7831       }
7832       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
7833
7834       /* Header Compression */
7835       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
7836        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
7837
7838       /* Reordering timer */
7839       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7840       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
7841       {
7842          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
7843          return RFAILED;
7844       }
7845       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7846
7847       drbIdx++;
7848    }
7849
7850    return ROK;
7851 }
7852
7853 /******************************************************************
7854  *
7855  * @brief Fill Radio bearer configuration
7856  *
7857  * @details
7858  *
7859  *    Function : fillRadioBearerConfig
7860  *
7861  *    Functionality: Fill Radio bearer configuration
7862  *
7863  * @params[in] UE control block
7864  *             Radio bearer config pointer
7865  * @return ROK     - success
7866  *         RFAILED - failure
7867  *
7868  * ****************************************************************/
7869 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
7870 {
7871    /* SRB To Add/Mod List */
7872    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
7873    {
7874       return RFAILED;
7875    }
7876
7877    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
7878    {
7879       return RFAILED;
7880    }
7881
7882    return ROK;
7883 }
7884
7885 /*******************************************************************
7886  *
7887  * @brief Fill measurement object to add/mod list
7888  *
7889  * @details
7890  *
7891  *    Function : fillMeasObjToAddModList
7892  *
7893  *    Functionality: Fill measurement object to add/mod list
7894  *
7895  * @params[in] Measurement object to add/mod list
7896  * @return ROK     - success
7897  *         RFAILED - failure
7898  *
7899  * ****************************************************************/
7900 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7901 {
7902    uint8_t elementCnt, objIdx;
7903    MeasObjectNR_t *measObject;
7904
7905    elementCnt = 1;
7906    measObjList->list.count = elementCnt;
7907    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
7908
7909    CU_ALLOC(measObjList->list.array, measObjList->list.size);
7910    if(!measObjList->list.array)
7911    {
7912       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
7913       return RFAILED;
7914    }
7915
7916    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7917    {
7918       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7919       if(!measObjList->list.array[objIdx])
7920       {
7921          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
7922          return RFAILED;
7923       }
7924    }
7925
7926    objIdx = 0;
7927    measObjList->list.array[objIdx]->measObjectId = 1;
7928    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
7929    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7930    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7931    {
7932       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
7933       return RFAILED;
7934    }
7935
7936    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7937
7938    /* SSB frequency */
7939    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7940    if(!measObject->ssbFrequency)
7941    {
7942       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
7943       return RFAILED;
7944    }
7945    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
7946
7947    /* Subcarrier spacing */
7948    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7949    if(!measObject->ssbSubcarrierSpacing)
7950    {
7951       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
7952       return RFAILED;
7953    }
7954    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
7955
7956    /* SMTC1 */
7957    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
7958    if(!measObject->smtc1)
7959    {
7960       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
7961       return RFAILED;
7962    }
7963    measObject->smtc1->duration = SSB_MTC__duration_sf1;
7964    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7965    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
7966
7967    /* Absoulute threshold SSB consolidation */
7968    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7969    if(!measObject->absThreshSS_BlocksConsolidation)
7970    {
7971       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
7972       return RFAILED;
7973    }
7974
7975    /* RSRP threshold */
7976    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7977    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
7978    {
7979       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
7980       return RFAILED;
7981    }
7982    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
7983
7984    /* RSRQ threshold */
7985    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7986    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
7987    {
7988       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
7989       return RFAILED;
7990    }
7991    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
7992
7993    /* SINR threshold */
7994    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7995    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
7996    {
7997       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
7998       return RFAILED;
7999    }
8000    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8001
8002    /* Number of SSBs to average */
8003    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8004    if(!measObject->nrofSS_BlocksToAverage)
8005    {
8006       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8007       return RFAILED;
8008    }
8009    *(measObject->nrofSS_BlocksToAverage) = 2;
8010
8011    /* Quantity Config index */
8012    measObject->quantityConfigIndex = 1;
8013
8014    /* Offset MO */
8015    /* RSRP offset for SSB */
8016    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8017    if(!measObject->offsetMO.rsrpOffsetSSB)
8018    {
8019       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8020       return RFAILED;
8021    }
8022    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8023
8024    /* RSRQ offset for SSB */
8025    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8026    if(!measObject->offsetMO.rsrpOffsetSSB)
8027    {
8028       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8029       return RFAILED;
8030    }
8031    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8032
8033    /* SINR offset for SSB */
8034    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8035    if(!measObject->offsetMO.sinrOffsetSSB)
8036    {
8037       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8038       return RFAILED;
8039    }
8040    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8041
8042    return ROK;
8043 }
8044
8045 /*******************************************************************
8046  *
8047  * @brief Fill Report configuration to Add/mod list
8048  *
8049  * @details
8050  *
8051  *    Function : fillReportCfgToAddModList
8052  *
8053  *    Functionality: Fill Report configuration to Add/mod list
8054  *
8055  * @params[in] Report Config To Add/Mod List
8056  * @return ROK     - success
8057  *         RFAILED - failure
8058  *
8059  * ****************************************************************/
8060 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8061 {
8062    uint8_t elementCnt;
8063    uint8_t reportCfgIdx;
8064    ReportConfigToAddMod_t *reportCfg;
8065    ReportConfigNR_t *reportCfgNr;
8066    EventTriggerConfig_t *eventTriggCfg;
8067
8068    elementCnt = 1;
8069    reportCfgList->list.count = elementCnt;
8070    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8071
8072    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8073    if(!reportCfgList->list.array)
8074    {
8075       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8076       return RFAILED;
8077    }
8078
8079    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8080    {
8081       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8082       if(!reportCfgList->list.array[reportCfgIdx])
8083       {
8084          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8085          return RFAILED;
8086       }
8087    }
8088
8089    reportCfgIdx = 0;
8090    reportCfg = reportCfgList->list.array[reportCfgIdx];
8091    reportCfg->reportConfigId = 1;
8092    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8093
8094    /* Report Configuration for NR */
8095    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8096    if(!reportCfg->reportConfig.choice.reportConfigNR)
8097    {
8098       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8099       return RFAILED;
8100    }
8101    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8102
8103    /* Report Type */
8104    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8105    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8106    if(!reportCfgNr->reportType.choice.eventTriggered)
8107    {
8108       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8109       return RFAILED;
8110    }
8111    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8112
8113    /* Event 3 */
8114    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8115    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8116    if(!eventTriggCfg->eventId.choice.eventA3)
8117    {
8118       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8119       return RFAILED;
8120    }
8121
8122    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8123    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8124    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8125    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8126    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8127    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8128
8129    /* Reference Signal Type */
8130    eventTriggCfg->rsType = NR_RS_Type_ssb;
8131
8132    /* Report Interval */
8133    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8134
8135    /* Report Amount */
8136    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8137
8138    /* Report Quantity cell */
8139    eventTriggCfg->reportQuantityCell.rsrp = true;
8140    eventTriggCfg->reportQuantityCell.rsrq = false;
8141    eventTriggCfg->reportQuantityCell.sinr = false;
8142
8143    /* Maximum reported cells */
8144    eventTriggCfg->maxReportCells = 3;
8145
8146    /* Report qunatity RS Indexes */
8147    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8148    if(!eventTriggCfg->reportQuantityRS_Indexes)
8149    {
8150       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8151       return RFAILED;
8152    }
8153    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8154    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8155    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8156
8157    /* Maximum number of RS indexes to report */
8158    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8159    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8160    {
8161       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8162       return RFAILED;
8163    }
8164    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8165
8166    /* Include Beam measurement */
8167    eventTriggCfg->includeBeamMeasurements = false;
8168
8169    return ROK;
8170 }
8171
8172 /*******************************************************************
8173  *
8174  * @brief Fill measurement Id to add/mod list
8175
8176  * @details
8177  *
8178  *    Function : fillMeasIdToAddModList
8179  *
8180  *    Functionality: Fill measurement Id to add/mod list
8181  *
8182  * @params[in] Measurement Id to add/mod list
8183  * @return ROK     - success
8184  *         RFAILED - failure
8185  *
8186  * ****************************************************************/
8187 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8188 {
8189    uint8_t elementCnt;
8190    uint8_t measIdIdx;
8191
8192    elementCnt = 1;
8193    measIdList->list.count = elementCnt;
8194    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8195
8196    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8197    if(!measIdList->list.array)
8198    {
8199       return RFAILED;
8200    }
8201
8202    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8203    {
8204       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8205       if(!measIdList->list.array[measIdIdx])
8206       {
8207          return RFAILED;
8208       }
8209
8210       measIdIdx=0;
8211       measIdList->list.array[measIdIdx]->measId = 1;
8212       measIdList->list.array[measIdIdx]->measObjectId = 1;
8213       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8214    }
8215    return ROK;
8216 }
8217
8218 /*******************************************************************
8219  *
8220  * @brief Fill s-measurement configuration
8221  *
8222  * @details
8223  *
8224  *    Function : fillSMeasConfig
8225  *
8226  *    Functionality: Fill s-measurement configuration
8227  *
8228  * @params[in] s-Measurement config
8229  * @return ROK     - success
8230  *         RFAILED - failure
8231  *
8232  * ****************************************************************/
8233 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8234 {
8235    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8236    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8237
8238    return ROK;
8239 }
8240
8241 /*******************************************************************
8242  *
8243  * @brief Fill quantity config
8244  *
8245  * @details
8246  *
8247  *    Function : fillQunatityConfig
8248  *
8249  *    Functionality: Fill quantity config
8250  *
8251  * @params[in] Quantity Config
8252  * @return ROK     - success
8253  *         RFAILED - failure
8254  *
8255  * ****************************************************************/
8256 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8257 {
8258    uint8_t elementCnt = 0;
8259    uint8_t quanCfgIdx = 0;
8260    QuantityConfigNR_t *quantityCfgNr;
8261
8262    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8263    if(!quantityCfg->quantityConfigNR_List)
8264    {
8265       return RFAILED;
8266    }
8267
8268    elementCnt = 1;
8269    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8270    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8271
8272    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8273    if(!quantityCfg->quantityConfigNR_List->list.array)
8274    {
8275       return RFAILED;
8276    }
8277
8278    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8279    {
8280       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8281       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8282       {
8283          return RFAILED;
8284       }
8285    }
8286
8287    quanCfgIdx = 0;
8288    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8289
8290    /* Quantity Config of Reference signal */
8291    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8292    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8293    {
8294       return RFAILED;
8295    }
8296    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8297
8298    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8299    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8300    {
8301       return RFAILED;
8302    }
8303    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8304
8305    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8306    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8307    {
8308       return RFAILED;
8309    }
8310    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8311
8312    /* Quantity Config RS index */
8313    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8314    if(!quantityCfgNr->quantityConfigRS_Index)
8315    {
8316       return RFAILED;
8317    }
8318
8319    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8320    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8321    {
8322       return RFAILED;
8323    }
8324    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8325
8326    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8327    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8328    {
8329       return RFAILED;
8330    }
8331    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8332
8333    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8334    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8335    {
8336       return RFAILED;
8337    }
8338    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8339
8340    return ROK;
8341 }
8342
8343 /*******************************************************************
8344  *
8345  * @brief Fill measurement configuration
8346  *
8347  * @details
8348  *
8349  *    Function : fillMeasConfig
8350  *
8351  *    Functionality: Fill measurement configuration
8352  *
8353  * @params[in] Measurement config
8354  * @return ROK     - success
8355  *         RFAILED - failure
8356  *
8357  * ****************************************************************/
8358 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8359 {
8360    /* Measurement object to add/mod list */
8361    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8362    if(!measConfig->measObjectToAddModList)
8363    {
8364       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8365       return RFAILED;
8366    }
8367    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8368    {
8369       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8370       return RFAILED;
8371    }
8372
8373    /* Report Config To add/mod list */
8374    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8375    if(!measConfig->reportConfigToAddModList)
8376    {
8377       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8378       return RFAILED;
8379    }
8380    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8381    {
8382       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8383       return RFAILED;
8384    }
8385
8386    /* Measurement Id to add/mod list */
8387    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8388    if(!measConfig->measIdToAddModList)
8389    {
8390       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8391       return RFAILED;
8392    }
8393    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8394    {
8395       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8396       return RFAILED;
8397    }
8398
8399    /* S-Measurement config */
8400    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8401    if(!measConfig->s_MeasureConfig)
8402    {
8403       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8404       return RFAILED;
8405    }
8406    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8407    {
8408       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8409       return RFAILED;
8410    }
8411
8412    /* Qunatity Config */
8413    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8414    if(!measConfig->quantityConfig)
8415    {
8416       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8417       return RFAILED;
8418    }
8419    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8420    {
8421       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8422       return RFAILED;
8423    }
8424
8425 return ROK;
8426 }
8427
8428 /*******************************************************************
8429  *
8430  * @brief Fill RRC reconfiguration non-critical extension IE
8431  *
8432  * @details
8433  *
8434  *    Function : fillRrcReconfigNonCriticalExt
8435  *
8436  *    Functionality: Fill RRC reconfiguration non-critical extension
8437  *
8438  * @params[in] RRC Reconfig Non-critical extension
8439  * @return ROK     - success
8440  *         RFAILED - failure
8441  *
8442  * ****************************************************************/
8443 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8444 {
8445    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8446    if(!rrcRecfg->masterCellGroup)
8447    {
8448       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8449       return RFAILED;
8450    }
8451
8452    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8453    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8454    if(!rrcRecfg->masterCellGroup->buf)
8455    {
8456       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8457       return RFAILED;
8458    }
8459    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8460
8461 #if 0
8462    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8463     * received from DU */
8464    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8465    {
8466       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8467       return RFAILED;
8468    }
8469 #endif
8470
8471    return ROK;
8472 }
8473
8474 /*******************************************************************
8475  *
8476  * @brief Fill RRC reconfiguration structure
8477  *
8478  * @details
8479  *
8480  *    Function : fillRrcReconfig
8481  *
8482  *    Functionality: Fill RRC reconfiguration
8483
8484  *
8485  * @params[in] UE Cb
8486  *             RRC reconfiguration structure
8487  * @return ROK     - success
8488  *         RFAILED - failure
8489  *
8490  * ****************************************************************/
8491 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8492 {
8493    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8494
8495    rrcReconfig->rrc_TransactionIdentifier = 1;
8496    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8497
8498    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8499    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8500    {
8501       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8502       return RFAILED;
8503    }
8504
8505    /* Radio Bearer Configuration */
8506    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8507    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8508    {
8509       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8510       return RFAILED;
8511    }
8512    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8513    {
8514       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8515       return RFAILED;
8516    }
8517
8518    /* Measurement Configuration */
8519    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8520    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8521    {
8522       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8523       return RFAILED;
8524    }
8525    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8526    {
8527       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8528       return RFAILED;
8529    }
8530
8531    /* Non Critical extension */
8532    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8533    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8534    {
8535       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8536       return RFAILED;
8537    }
8538    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8539    {
8540       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8541       return RFAILED;
8542    }
8543    return ROK;
8544 }
8545
8546 /*******************************************************************
8547  *
8548  * @brief Fill RRC reconfiguration Octet string
8549  *
8550  * @details
8551  *
8552  *    Function : fillRrcReconfigBuf
8553  *
8554  *    Functionality: Fill RRC reconfiguration octet string
8555
8556  *
8557  * @params[in] OCTET_STRING_t buffer
8558  * @return ROK     - success
8559  *         RFAILED - failure
8560  *
8561  * ****************************************************************/
8562 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8563 {
8564    uint8_t          ret = RFAILED;
8565    asn_enc_rval_t   encRetVal;
8566    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8567    rrcReconfig = &rrcRecfg;
8568
8569    while(true)
8570    {
8571       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8572       {
8573          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8574          break;
8575       }
8576
8577       /* Encode RRC Reconfiguration */
8578       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8579       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8580       encBufSize = 0;
8581       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8582
8583       /* Encode results */
8584       if(encRetVal.encoded == ENCODE_FAIL)
8585       {
8586          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8587                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8588          break;
8589       }
8590       else
8591       {
8592          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8593          for(int i=0; i< encBufSize; i++)
8594          {
8595             DU_LOG("%x",encBuf[i]);
8596          }
8597       }
8598
8599       rrcReconfigBuf->size = encBufSize;
8600       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8601       if(!rrcReconfigBuf->buf)
8602       {
8603          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8604          break;
8605       }
8606       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8607       ret = ROK;
8608       break;
8609    }
8610
8611    freeRrcReconfig(rrcReconfig);
8612    return ret;
8613 }
8614
8615 /*******************************************************************
8616  *
8617  * @brief Fill HO preparation information Octet string
8618  *
8619  * @details
8620  *
8621  *    Function : fillHOPreparationInfoBuf
8622  *
8623  *    Functionality: Fill HO preparation information Octet string
8624
8625  *
8626  * @params[in] HandoverPreparationInformation_t buffer
8627  * @return ROK     - success
8628  *         RFAILED - failure
8629  *
8630  * ****************************************************************/
8631 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8632 {
8633    uint8_t          ret = RFAILED;
8634    asn_enc_rval_t   encRetVal;
8635    HandoverPreparationInformationRrc_t hoPrepInfo;
8636    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8637
8638    while(true)
8639    {
8640
8641       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8642       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8643       if(!hoPrepInfo.criticalExtensions.choice.c1)
8644       {
8645          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8646          break;
8647       }
8648       hoPrepInfo.criticalExtensions.choice.c1->present = \
8649          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8650
8651       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8652          sizeof(HandoverPreparationInformationRrc_IEs_t));
8653       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8654       {
8655          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8656          break;
8657       }
8658       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8659
8660       /* Fill UE Capability RAT container list */
8661       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8662       if(ret != ROK)
8663       {
8664          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8665          break;
8666       }
8667
8668       /* Fill Source config */
8669       hoPrepInfoIe->sourceConfig = NULLP;
8670       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8671       if(!hoPrepInfoIe->sourceConfig)
8672       {
8673          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8674          return RFAILED;
8675       }
8676       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8677
8678       if(ret != ROK)
8679       {
8680          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8681          return RFAILED;
8682       }
8683
8684       hoPrepInfoIe->rrm_Config = NULLP;
8685       hoPrepInfoIe->as_Context = NULLP;
8686       hoPrepInfoIe->nonCriticalExtension = NULLP;
8687
8688       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8689       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8690       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8691       encBufSize = 0;
8692       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8693             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8694
8695       /* Encode results */
8696       if(encRetVal.encoded == ENCODE_FAIL)
8697       {
8698          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8699                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8700          break;
8701       }
8702       else
8703       {
8704          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8705          for(int i=0; i< encBufSize; i++)
8706          {
8707             DU_LOG("%x",encBuf[i]);
8708          }
8709       }
8710
8711       hoPrepInfoBuf->size = encBufSize;
8712       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8713       if(!hoPrepInfoBuf->buf)
8714       {
8715          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8716          break;
8717       }
8718       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8719       ret = ROK;
8720       break;
8721    }
8722    freeHOPreparationInfo(&hoPrepInfo);
8723    return ret;
8724 }
8725
8726 /*******************************************************************
8727  *
8728  * @brief Fills CuToDuContainer
8729  *
8730  * @details
8731  *
8732  *    Function : fillCuToDuContainer
8733  *
8734  *    Functionality: Fills CuToDuContainer
8735  *
8736  * @params[in] pointer to CUtoDURRCInformation_t
8737  *
8738  * @return ROK     - success
8739  *         RFAILED - failure
8740  *
8741  ******************************************************************/
8742
8743 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8744 {
8745    uint8_t elementCnt = 0;
8746    uint8_t ret = ROK;
8747    uint8_t idx, idx2, rrcBufLen;
8748
8749    /* UE Capabulity RAT Container List */
8750    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8751    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8752    {
8753       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8754       return RFAILED;
8755    }
8756    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8757
8758    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8759    if(!rrcMsg->measConfig)
8760    {
8761       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8762       return RFAILED;
8763    }
8764    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8765
8766    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8767    {
8768       /* IE extensions */
8769       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8770       if(rrcMsg->iE_Extensions)
8771       {
8772          elementCnt = 1;
8773          rrcMsg->iE_Extensions->list.count = elementCnt;
8774          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8775
8776          /* Initialize the CUtoDURRCInformation_ExtIEs */
8777          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8778
8779          if(rrcMsg->iE_Extensions->list.array == NULLP)
8780          {
8781             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8782             ret = RFAILED;
8783          }
8784
8785          for(idx=0; idx<elementCnt; idx++)
8786          {
8787             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8788             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8789             {
8790                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8791                ret = RFAILED;
8792             }
8793          }
8794
8795          idx = 0;
8796 #if 0
8797          /* Cell Group Configuration */
8798          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
8799          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8800          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
8801                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
8802          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
8803          idx++;
8804 #endif
8805          /* Handover Preparation Information */
8806          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
8807          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8808          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
8809                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
8810          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
8811       }
8812    }
8813    return ret;
8814 }
8815
8816 /*******************************************************************
8817  *
8818  * @brief Free CuToDuContainer
8819  *
8820  * @details
8821  *
8822  *    Function : FreeCuToDuInfo
8823  *
8824  *    Functionality: Free CuToDuContainer
8825  *
8826  * @params[in] pointer to CUtoDURRCInformation_t
8827  *
8828  * @return ROK     - success
8829  *         RFAILED - failure
8830  *
8831  ******************************************************************/
8832
8833 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8834 {
8835    uint8_t idx, idx2;
8836
8837    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8838    {
8839       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8840          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
8841       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8842    }
8843    if(rrcMsg->iE_Extensions)
8844    {
8845       if(rrcMsg->iE_Extensions->list.array)
8846       {
8847          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
8848          {
8849             if(rrcMsg->iE_Extensions->list.array[idx])
8850             {
8851                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
8852                {
8853                   case ProtocolIE_ID_id_CellGroupConfig:
8854                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8855                      {
8856                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
8857                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
8858
8859                      }
8860                      break;
8861                   default:
8862                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8863                            rrcMsg->iE_Extensions->list.array[idx]->id);
8864                      break;
8865                }
8866             }
8867             break;
8868          }
8869          for(idx2 = 0; idx2 < idx; idx2++)
8870          {
8871             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
8872          }
8873          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8874
8875       }
8876
8877       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8878    }
8879 }
8880 /*******************************************************************
8881  *
8882  * @brief Builds and sends the UE Setup Request
8883  *
8884  * @details
8885  *
8886  *    Function : BuildAndSendUeContextSetupReq
8887  *
8888  *    Functionality: Constructs the UE Setup Request and sends
8889  *                   it to the CU through SCTP.
8890  *
8891  * @params[in]
8892  *
8893  * @return ROK     - success
8894  *         RFAILED - failure
8895  *
8896  * ****************************************************************/
8897 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb, uint16_t rrcContLen, uint8_t *rrcContainer)
8898 {
8899    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
8900    uint8_t   ret= RFAILED, ret1;
8901    uint8_t   elementCnt;
8902    uint8_t   idx, idx1, bufLen, duIdx;
8903    uint32_t  spCellId;
8904    DuDb      *targetDuDb = NULLP;
8905    F1AP_PDU_t           *f1apMsg = NULLP;
8906    UEContextSetupRequest_t *ueSetReq = NULLP;
8907    asn_enc_rval_t encRetVal;        /* Encoder return value */
8908    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8909
8910    while(true)
8911    {
8912       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
8913
8914       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8915       if(f1apMsg == NULLP)
8916       {
8917          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8918          break;
8919       }
8920
8921       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8922       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8923       if(f1apMsg->choice.initiatingMessage == NULLP)
8924       {
8925          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
8926          break;
8927       }
8928
8929       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
8930       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8931       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
8932
8933       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
8934
8935       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8936          elementCnt = 7;
8937       else
8938          elementCnt = 12;
8939       ueSetReq->protocolIEs.list.count = elementCnt;
8940       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
8941
8942       /* Initialize the UESetup members */
8943       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
8944
8945       if(ueSetReq->protocolIEs.list.array == NULLP)
8946       {
8947          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
8948          break;
8949       }
8950
8951       for(idx1=0; idx1<elementCnt; idx1++)
8952       {
8953          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
8954          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
8955          {
8956             break;
8957          }
8958       }
8959
8960       idx = 0;
8961
8962       /*GNB CU UE F1AP ID*/
8963       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8964       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8965       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8966       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
8967
8968       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8969       {
8970          /*GNB DU UE F1AP ID*/
8971          idx++;
8972          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8973          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8974          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8975          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
8976       }
8977
8978       /*Special Cell ID*/
8979       idx++;
8980       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
8981       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8982       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
8983       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8984       {
8985          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
8986          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
8987          /* Since we are supporting only one cell per DU, accessing 0th index to
8988           * get target cell info */
8989          spCellId = targetDuDb->cellCb[0].nrCellId;
8990       }
8991       else
8992          spCellId = ueCb->cellCb->nrCellId;
8993       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
8994       if(Nrcgiret != ROK)
8995       {
8996          break;
8997       }
8998
8999       /*Served Cell Index*/
9000       idx++;
9001       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9002       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9003       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9004       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9005
9006       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9007       {
9008          /*CellULConfigured*/
9009          idx++;
9010          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9011          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9012          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9013          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9014       }
9015
9016       /*CUtoDURRCContainer*/
9017       idx++;
9018       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9019       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9020       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9021       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9022       {
9023          break;
9024       }
9025
9026       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9027       {
9028          /*Special Cells to be SetupList*/
9029          idx++;
9030          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9031          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9032          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9033          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9034          if(SplCellListret != ROK)
9035          {
9036             break;
9037          }
9038       }
9039
9040       /*SRBs To Be Setup List*/
9041       idx++;
9042       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9043       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9044       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9045       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9046       if(SrbSetupret != ROK)
9047       {
9048          break;
9049       }
9050
9051       /*DRBs to Be Setup List*/
9052       idx++;
9053       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9054       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9055       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9056       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9057       if(ret1 != ROK)
9058       {
9059          break;
9060       }
9061
9062       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9063       {
9064          /* RRC Container for security mode */
9065          idx++;
9066          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
9067          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9068          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCContainer;
9069
9070          char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
9071          bufLen =9;
9072          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
9073          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
9074                ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
9075          if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
9076          {
9077             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
9078             break;
9079          }
9080          memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
9081          memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
9082
9083          /* RRC delivery status request */
9084          idx++;
9085          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9086          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9087          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9088          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9089       }
9090
9091       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9092       idx++;
9093       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9094       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9095       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9096
9097       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9098       bufLen = 4;
9099       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9100       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9101             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9102       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9103       {
9104          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9105          break;
9106       }
9107       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9108       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9109
9110       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9111
9112       /* Encode the F1SetupRequest type as APER */
9113       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9114       encBufSize = 0;
9115       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9116
9117       /* Encode results */
9118       if(encRetVal.encoded == ENCODE_FAIL)
9119       {
9120          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9121                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9122          break;
9123       }
9124       else
9125       {
9126          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9127          for(int i=0; i< encBufSize; i++)
9128          {
9129             DU_LOG("%x",encBuf[i]);
9130          }
9131       }
9132
9133       /* Sending  msg  */
9134       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9135       {
9136          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9137          break;
9138       }
9139       ret = ROK;
9140       break;
9141    }
9142    FreeUeContextSetupReq(f1apMsg);
9143
9144    return ret;
9145 }/* End of BuildAndSendUeContextSetupReq*/
9146
9147 /**********************************************************************
9148  * @brief Function to extractTeId received in UE context setup Response
9149  *
9150  * @details
9151  *
9152  *    Function : extractTeId
9153  *
9154  *    Functionality:
9155  *         - Function to extract TeId
9156  *
9157  * @params[in]
9158  * @return ROK     - success
9159  *         RFAILED - failure
9160  *
9161  **********************************************************************/
9162 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9163 {
9164    uint8_t arrIdx = 0;
9165    uint32_t teId = 0;
9166    GTPTunnel_t *gtpDl = NULLP;
9167
9168    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9169    {
9170       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9171       {
9172          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9173          {
9174             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9175             if(gtpDl->gTP_TEID.size > 0)
9176             {
9177                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9178             }
9179             else
9180                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9181             return(teId);
9182          }
9183       }
9184    }
9185    return teId;
9186 }
9187
9188 /****************************************************************
9189  * @brief Function to add Drb tunnels
9190  *
9191  * @details
9192  *
9193  *    Function : addDrbTunnels
9194  *
9195  *    Functionality:
9196  *         - Function to add Drb tunnels
9197  *
9198  * @params[in]
9199  * @return ROK     - success
9200  *         RFAILED - failure
9201  *
9202  * ****************************************************************/
9203 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9204 {
9205    uint8_t ret = ROK;
9206    EgtpTnlEvt tnlEvt;
9207
9208    if(teId > MAX_TEID || teId < MIN_TEID)
9209    {
9210       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9211    }
9212    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9213    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9214    tnlEvt.lclTeid = teId;
9215    tnlEvt.remTeid = teId;
9216    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9217    if(ret != ROK)
9218    {
9219       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9220    }
9221    return ROK;
9222 }
9223
9224 /****************************************************************
9225  * @brief Function to process Drb Setup List
9226  *
9227  * @details
9228  *
9229  *    Function : procDrbSetupList
9230  *
9231  *    Functionality:
9232  *         - Function to process DRB Setup List
9233  *
9234  * @params[in]
9235  * @return ROK     - success
9236  *         RFAILED - failure
9237  *
9238  * ****************************************************************/
9239 uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList)
9240 {
9241    uint8_t arrIdx = 0;
9242    uint32_t teId = 0;
9243    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9244
9245    if(drbSetupList != NULLP)
9246    {
9247       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9248       {
9249          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9250          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9251          {
9252             /* extracting teId */
9253             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9254             if(teId > 0)
9255             {
9256               if(addDrbTunnels(duId, teId)== ROK)
9257               {
9258                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9259               }
9260             }
9261             else
9262                return RFAILED;
9263          }
9264       }
9265    }
9266    return ROK;
9267 }
9268
9269 /****************************************************************
9270  * @brief Function to process Ue Context Setup Response
9271  *
9272  * @details
9273  *
9274  *    Function : procUeContextSetupResponse
9275  *
9276  *    Functionality:
9277  *         - Function to process Ue Context Setup Response
9278  *
9279  * @params[in]
9280  * @return ROK     - success
9281  *         RFAILED - failure
9282  *
9283  * ****************************************************************/
9284 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9285 {
9286    uint8_t duIdx = 0, idx = 0, ueIdx = 0;
9287    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9288    DuDb *duDb = NULLP;
9289    CuUeCb *ueCb = NULLP;
9290    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9291    OCTET_STRING_t *duToCuRrcContainer;
9292
9293    SEARCH_DU_DB(duIdx, duId, duDb);
9294    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9295
9296    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9297    {
9298       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9299       {
9300           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9301              {
9302                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9303                break;
9304              }
9305           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9306              {
9307                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9308                 ueCb = &duDb->ueCb[duUeF1apId-1];
9309                 /* If ue context is not present in du db, then create UE context
9310                  * here. This flow is hit in case of UE handover where UE
9311                  * context is created before UE performs RACH on target DU */
9312                 if(ueCb->gnbDuUeF1apId == 0)
9313                 {
9314                    /* Creating UE context in target DU */
9315                    memset(ueCb, 0, sizeof(CuUeCb));
9316                    ueCb->cellCb = &duDb->cellCb[0];
9317                    ueCb->gnbDuUeF1apId = duUeF1apId;
9318                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9319                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9320                    ueCb->hoInfo.targetDuId = duId;
9321                    (duDb->numUe)++;
9322
9323                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9324                    ueCb->cellCb->numUe++;
9325                 }
9326                 break;
9327              }
9328           case ProtocolIE_ID_id_C_RNTI:
9329              {
9330                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9331                 break;
9332              }
9333           case ProtocolIE_ID_id_DRBs_Setup_List:
9334              {
9335                 /* Adding Tunnels for successful DRB */
9336                 procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9337                 break;
9338              }
9339          case ProtocolIE_ID_id_DUtoCURRCInformation:
9340              {
9341                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9342                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9343                    DUtoCURRCInformation.cellGroupConfig;
9344                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9345                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9346                 {
9347                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9348                    return RFAILED;
9349                 }
9350                 break;
9351              }
9352       }
9353    }
9354
9355    ueCb->f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
9356
9357    /* If the UE is in handover, UE context modification request is to be sent to
9358     * source DU once UE context setup response is received from target DU */
9359    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9360    {
9361       DuDb *srcDuDb = NULLP;
9362       CuUeCb *ueCbInSrcDu = NULLP;
9363
9364       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9365        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9366       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9367       {
9368          /* UE context setup response is received from target DU. Search all
9369           * DUs to find source DU except this target DU Id.*/
9370          if(cuCb.duInfo[duIdx].duId != duId)
9371          {
9372             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9373             {
9374                /* Check following:
9375                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9376                 * received in UE context setup response since CU UE F1AP ID does not
9377                 * change for UE in handover.
9378                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9379                 */
9380                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9381                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9382                {
9383                   srcDuDb = &cuCb.duInfo[duIdx];
9384                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9385
9386                   /* Store source DU info in the new UE context created in
9387                    * tareget DU */
9388                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9389
9390                   /* Copy the received container to UeCb */
9391                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9392
9393                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9394                   {
9395                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9396                      return RFAILED;
9397                   }
9398                   break;
9399                }
9400             }
9401          }
9402          if(srcDuDb && ueCbInSrcDu)
9403             break;
9404       }
9405    }
9406    return ROK;
9407 }
9408
9409 /****************************************************************
9410  * @brief Function to process Ul Rrc Msg received from DU
9411  *
9412  * @details
9413  *
9414  *    Function : procUlRrcMsg
9415  *
9416  *    Functionality:
9417  *         - Function to process Ul Rrc Msg received from DU
9418  *
9419  * @params[in]
9420  * @return ROK     - success
9421  *         RFAILED - failure
9422  *
9423  * ****************************************************************/
9424
9425 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9426 {
9427    uint8_t idx, ret, srbId, rrcMsgType, duIdx=0;
9428    uint8_t cuUeF1apId, duUeF1apId;
9429    uint8_t *rrcContainer = NULLP;
9430    uint16_t rrcContLen;
9431    DuDb     *duDb;
9432    CuUeCb   *ueCb;
9433    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9434
9435    ret = ROK;
9436    SEARCH_DU_DB(duIdx, duId, duDb);
9437    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9438
9439    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9440    {
9441       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9442       {
9443          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9444             {
9445                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9446                break;
9447             }
9448          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9449             {
9450                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9451                break;
9452             }
9453          case ProtocolIE_ID_id_SRBID:
9454             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9455             break;
9456
9457          case ProtocolIE_ID_id_RRCContainer:
9458             {
9459                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9460                CU_ALLOC(rrcContainer, rrcContLen);
9461                if(!rrcContainer)
9462                {
9463                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9464                   return RFAILED;
9465                }
9466                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9467                break;
9468             }
9469
9470          default:
9471             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9472             break;
9473       }
9474    }
9475
9476    if(srbId == 1)
9477    {
9478       ueCb = &duDb->ueCb[duUeF1apId-1];
9479       ueCb->f1apMsgDb.dlRrcMsgCount++;
9480       rrcMsgType = setDlRRCMsgType(ueCb);
9481       if(rrcMsgType == REGISTRATION_ACCEPT)
9482       {
9483          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9484          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9485       }
9486       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
9487       {
9488          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Req");
9489          ret = BuildAndSendUeContextSetupReq(duId, ueCb, rrcContLen, rrcContainer);
9490       }
9491       if(rrcMsgType == SECURITY_MODE_COMPLETE)
9492       {
9493          /* To trigger the DL RRC Msg for RRC Reconfig */
9494          ueCb->f1apMsgDb.dlRrcMsgCount++;
9495          rrcMsgType = setDlRRCMsgType(ueCb);
9496          if(rrcMsgType == RRC_RECONFIG)
9497          {
9498             DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Reconfig");
9499             BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9500          }
9501       }
9502       if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9503       {
9504          ueCb->state = UE_ACTIVE;
9505          ueCb->f1apMsgDb.dlRrcMsgCount++;
9506          rrcMsgType = setDlRRCMsgType(ueCb);
9507          if(rrcMsgType == UE_CONTEXT_MOD_REQ)
9508          {
9509             DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9510             BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9511          }
9512       }
9513    }
9514    return ret;
9515 }
9516
9517 /****************************************************************
9518  * @brief Build And Send F1ResetAck
9519  *
9520  * @details
9521  *
9522  *    Function : FreeF1ResetAck
9523  *
9524  *    Functionality:
9525  *         - Build And Send  F1ResetRSP
9526  *
9527  *  @params[in]
9528  * @return ROK     - success
9529  *         RFAILED - failure
9530  *
9531  * ****************************************************************/
9532 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9533 {
9534    uint8_t idx;
9535    ResetAcknowledge_t *f1ResetAck;
9536
9537    if(f1apMsg)
9538    {
9539       if(f1apMsg->choice.successfulOutcome)
9540       {
9541          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9542
9543          if(f1ResetAck->protocolIEs.list.array)
9544          {
9545             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9546             {
9547                if(f1ResetAck->protocolIEs.list.array[idx])
9548                {
9549                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9550                }
9551             }
9552             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9553          }
9554          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9555       }
9556       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9557    }
9558 }
9559
9560 /****************************************************************
9561  * @brief Build And Send F1ResetAck
9562  *
9563  * @details
9564  *
9565  *    Function : BuildAndSendF1ResetAck
9566  *
9567  *    Functionality:
9568  *         - Build And Send  F1ResetRSP
9569  *
9570  *  @params[in]
9571  * @return ROK     - success
9572  *         RFAILED - failure
9573  *
9574  * ****************************************************************/
9575
9576 uint8_t BuildAndSendF1ResetAck()
9577 {
9578    uint8_t                idx = 0;
9579    uint8_t                elementCnt = 0;
9580    uint8_t                ret = RFAILED;
9581    F1AP_PDU_t             *f1apMsg = NULL;
9582    ResetAcknowledge_t     *f1ResetAck = NULLP;
9583    asn_enc_rval_t         encRetVal;
9584    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9585
9586    do{
9587       /* Allocate the memory for F1ResetRequest_t */
9588       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9589       if(f1apMsg == NULLP)
9590       {
9591          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9592          break;
9593       }
9594
9595       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9596
9597       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9598       if(f1apMsg->choice.successfulOutcome == NULLP)
9599       {
9600          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9601          break;
9602       }
9603
9604       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9605       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9606       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9607       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9608
9609       elementCnt = 1;
9610
9611       f1ResetAck->protocolIEs.list.count = elementCnt;
9612       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9613
9614       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9615       if(f1ResetAck->protocolIEs.list.array == NULLP)
9616       {
9617          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9618          break;
9619       }
9620
9621       for(idx=0; idx<elementCnt; idx++)
9622       {
9623          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9624          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9625          {
9626             break;
9627          }
9628       }
9629       /*TransactionID*/
9630       idx = 0;
9631       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9632       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9633       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9634       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9635
9636       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9637
9638       /* Encode the F1SetupRequest type as UPER */
9639       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9640       encBufSize = 0;
9641       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9642
9643       /* Check encode results */
9644       if(encRetVal.encoded == ENCODE_FAIL)
9645       {
9646          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9647                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9648          break;
9649       }
9650       else
9651       {
9652          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9653          for(int i=0; i< encBufSize; i++)
9654          {
9655             DU_LOG("%x",encBuf[i]);
9656          }
9657       }
9658
9659       /* Sending msg */
9660       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9661       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9662       {
9663          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9664          break;
9665       }
9666
9667       ret = ROK;
9668       break;
9669    }while(true);
9670
9671    FreeF1ResetAck(f1apMsg);
9672    return ret;
9673 }
9674
9675 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9676 {
9677    uint8_t arrIdx =0;
9678
9679    if(ulInfo->list.array)
9680    {
9681       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9682       {
9683          if(ulInfo->list.array[arrIdx])
9684          {
9685             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9686             {
9687                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9688                {
9689                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9690                   {
9691                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9692                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9693                      gTPTunnel->gTP_TEID.size);
9694                   }
9695                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9696                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9697                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9698                }
9699                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9700                sizeof(GTPTunnel_t));
9701             }
9702             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9703          }
9704       }
9705       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9706    }
9707 }
9708
9709 /*******************************************************************
9710 *
9711 * @brief Deletes the EGTP tunnel
9712 *
9713 * @details
9714 *
9715 *    Function : deleteEgtpTunnel
9716 *
9717 *    Functionality: Deletes the EGTP tunnel
9718 *
9719 * @params[in] uint8_t *buf
9720 *
9721 * @return ROK     - success
9722 *         RFAILED - failure
9723 *
9724 * ****************************************************************/
9725 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
9726 {
9727    uint32_t teId = 0;
9728    EgtpTnlEvt tnlEvt;
9729
9730    teIdStringToInt(buf, &teId);
9731    if(teId > MAX_TEID || teId < MIN_TEID)
9732    {
9733       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
9734       return RFAILED;
9735    }
9736    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9737    tnlEvt.action = EGTP_TNL_MGMT_DEL;
9738    tnlEvt.lclTeid = teId;
9739    tnlEvt.remTeid = teId;
9740    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
9741    {
9742       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
9743    }
9744    return ROK;
9745 }
9746
9747 /*******************************************************************
9748 *
9749 * @brief Builds the Uplink Tunnel Info
9750 *
9751 * @details
9752 *
9753 *    Function : BuildUlTnlInfoforSetupMod
9754 *
9755 *    Functionality: Constructs the UL TnlInfo For DRB list
9756 *
9757 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9758 *
9759 * @return ROK     - success
9760 *         RFAILED - failure
9761 *
9762 * ****************************************************************/
9763 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
9764 {
9765    uint8_t arrIdx;
9766    uint8_t ulCnt;
9767
9768    ulCnt = 1;
9769    ulInfo->list.count = ulCnt;
9770    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
9771    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
9772    if(ulInfo->list.array == NULLP)
9773    {
9774       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9775       return RFAILED;
9776    }
9777    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
9778    {
9779       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9780       if(ulInfo->list.array[arrIdx] == NULLP)
9781       {
9782          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9783          return RFAILED;
9784       }
9785    }
9786
9787    arrIdx = 0;
9788    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
9789    UPTransportLayerInformation_PR_gTPTunnel;
9790
9791    /*GTP TUNNEL*/
9792    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9793          sizeof(GTPTunnel_t));
9794    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
9795    {
9796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9797       return RFAILED;
9798    }
9799    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9800       transportLayerAddress.size        = 4*sizeof(uint8_t);
9801    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9802          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9803          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9804    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9805          transportLayerAddress.buf == NULLP)
9806    {
9807       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9808       return RFAILED;
9809    }
9810
9811    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9812       transportLayerAddress.buf[0] = 192;
9813    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9814       transportLayerAddress.buf[1] = 168;
9815    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9816       transportLayerAddress.buf[2] = 130;
9817    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9818       transportLayerAddress.buf[3] = 82;
9819    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9820       transportLayerAddress.bits_unused = 0;
9821
9822    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
9823    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
9824    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
9825    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
9826
9827    /*GTP TEID*/
9828    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
9829       = 4 * sizeof(uint8_t);
9830    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9831          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9832          gTPTunnel->gTP_TEID.size);
9833    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9834          == NULLP)
9835    {
9836       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9837       return RFAILED;
9838    }
9839    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9840       gTP_TEID.buf[0] = 0;
9841    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9842       gTP_TEID.buf[1] = 0;
9843    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9844       gTP_TEID.buf[2] = 0;
9845    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
9846    {
9847      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
9848       * fetched based on the Drb Id */
9849
9850      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
9851       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
9852                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
9853    }
9854    else
9855    {
9856       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9857         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
9858    }
9859
9860    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
9861    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
9862    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
9863    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
9864    return ROK;
9865 }/*End of BuildULTnlInfo*/
9866
9867 /*******************************************************************
9868 *
9869 * @brief freeing the DRB item
9870 *
9871 * @details
9872 *
9873 *    Function : FreeDrbItem
9874 *
9875 *    Functionality: freeing the DRB item
9876 *
9877 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9878 *
9879 * @return ROK     - success
9880 *         RFAILED - failure
9881 *
9882 * ****************************************************************/
9883
9884 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
9885 {
9886    uint8_t arrIdx =0;
9887    SNSSAI_t *snssai =NULLP;
9888    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
9889
9890    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9891    switch(drbItem->qoSInformation.present)
9892    {
9893       case QoSInformation_PR_NOTHING:
9894          break;
9895       case QoSInformation_PR_eUTRANQoS:
9896          {
9897             if(drbItem->qoSInformation.choice.eUTRANQoS)
9898             {
9899                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9900             }
9901             break;
9902          }
9903       case QoSInformation_PR_choice_extension:
9904          {
9905             if(drbItem->qoSInformation.choice.choice_extension)
9906             {
9907                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
9908
9909                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
9910                if(snssai->sST.buf)
9911                {
9912                   CU_FREE(snssai->sST.buf,snssai->sST.size);
9913                }
9914                if(snssai->sD)
9915                {
9916                   if(snssai->sD->buf)
9917                   {
9918                      CU_FREE(snssai->sD->buf,snssai->sD->size);
9919                   }
9920                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
9921                }
9922
9923                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
9924                if(flowMap->list.array)
9925                {
9926                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
9927                   {
9928                      if(flowMap->list.array[arrIdx] )
9929                      {
9930                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
9931                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
9932                      }
9933                   }
9934                   CU_FREE(flowMap->list.array,flowMap->list.size);
9935                }
9936
9937                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9938             }
9939             break;
9940          }
9941
9942    }
9943    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
9944    if(drbItem->uLConfiguration)
9945    {
9946       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
9947    }
9948 }
9949
9950 /*******************************************************************
9951 *
9952 * @brief filling the DRB setup Mod item
9953 *
9954 * @details
9955 *
9956 *    Function : FillDrbItemToSetupMod
9957 *
9958 *    Functionality: filling the DRB setup Mod item
9959 *
9960 *
9961 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9962 *
9963 * @return ROK     - success
9964 *         RFAILED - failure
9965 *
9966 * ****************************************************************/
9967
9968 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
9969 {
9970    uint8_t ret = ROK;
9971
9972    /*Drb Id */
9973    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
9974    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
9975
9976    /*qoSInformation*/
9977    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9978
9979    switch(drbItem->qoSInformation.present)
9980    {
9981       case QoSInformation_PR_NOTHING:
9982       {
9983          break;
9984       }
9985       case QoSInformation_PR_eUTRANQoS:
9986       {
9987
9988          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9989          if(drbItem->qoSInformation.choice.eUTRANQoS)
9990          {
9991             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9992             return RFAILED;
9993          }
9994          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
9995          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
9996             PriorityLevel_no_priority;
9997
9998          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
9999             Pre_emptionCapability_may_trigger_pre_emption;
10000
10001          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10002             Pre_emptionVulnerability_pre_emptable;
10003
10004          break;
10005       }
10006       case QoSInformation_PR_choice_extension:
10007       {
10008          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10009          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10010          {
10011             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10012             return RFAILED;
10013          }
10014
10015          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10016          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10017          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10018          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10019            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10020          if(ret != ROK)
10021          {
10022             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10023             return RFAILED;
10024          }
10025
10026          /*SNSSAI*/
10027          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10028                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10029          if(ret != ROK)
10030          {
10031             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10032             return RFAILED;
10033          }
10034
10035          /*Flows mapped to DRB List*/
10036          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10037                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10038           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10039          if(ret != ROK)
10040          {
10041             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10042             return RFAILED;
10043          }
10044       }
10045    }
10046
10047    /*ULUPTNLInformation To Be Setup List*/
10048    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10049       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10050    if(ret != ROK)
10051    {
10052       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10053       return RFAILED;
10054    }
10055
10056    /*RLCMode*/
10057    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10058    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10059
10060    ueCb->numDrb++;
10061    return ROK;
10062 }
10063
10064 /*******************************************************************
10065 *
10066 * @brief Builds the DRB to be Setup Mod ItemIes
10067 *
10068 * @details
10069 *
10070 *    Function : FillDrbItemList
10071 *
10072 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10073 *
10074 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10075 *
10076 * @return ROK     - success
10077 *         RFAILED - failure
10078 *
10079 * ****************************************************************/
10080
10081 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10082 {
10083    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10084    drbItemIe->criticality = Criticality_reject;
10085    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10086
10087    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10088    {
10089       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10090       return RFAILED;
10091    }
10092    return ROK;
10093 }
10094 /*******************************************************************
10095 *
10096 * @brief free the DRB to be Setup Mod list
10097 *
10098 * @details
10099 *
10100 *    Function : FreeDrbToBeSetupModList
10101 *
10102 *    Functionality: free the DRB to be Setup Mod list
10103 *
10104 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10105 *
10106 * @return ROK     - success
10107 *         RFAILED - failure
10108 *
10109 * ****************************************************************/
10110 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10111 {
10112    uint8_t arrIdx =0;
10113    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10114
10115    if(drbSet->list.array)
10116    {
10117       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10118       {
10119          if(drbSet->list.array[arrIdx] != NULLP)
10120          {
10121             if(arrIdx == 0)
10122             {
10123                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10124                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10125             }
10126             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10127          }
10128       }
10129       CU_FREE(drbSet->list.array, drbSet->list.size);
10130    }
10131
10132 }
10133
10134 /*******************************************************************
10135 *
10136 * @brief Builds the DRB to be Setup Mod list
10137 *
10138 * @details
10139 *
10140 *    Function : BuildDrbToBeSetupList
10141 *
10142 *    Functionality: Constructs the DRB to be Setup Mod list
10143 *
10144 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10145 *
10146 * @return ROK     - success
10147 *         RFAILED - failure
10148 *
10149 * ****************************************************************/
10150
10151 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10152 {
10153    uint8_t ret = ROK;
10154    uint8_t arrIdx =0;
10155    uint8_t drbCnt =0;
10156
10157    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10158    drbSet->list.count = drbCnt;
10159    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10160    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10161    if(drbSet->list.array == NULLP)
10162    {
10163       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10164       return  RFAILED;
10165    }
10166
10167    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10168    {
10169       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10170       if(drbSet->list.array[arrIdx] == NULLP)
10171       {
10172          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10173          return  RFAILED;
10174       }
10175
10176       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10177       if(ret != ROK)
10178       {
10179          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10180       }
10181    }
10182
10183    return ret;
10184 }
10185
10186 /*******************************************************************
10187 *
10188 * @brief Filling the DRB to be modified item
10189 *
10190 * @details
10191 *
10192 *    Function : FillDrbToBeModItem
10193 *
10194 *    Functionality: filling the DRB to be modified item
10195 *
10196 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10197 *
10198 * @return ROK     - success
10199 *         RFAILED - failure
10200 *
10201 * ****************************************************************/
10202
10203 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10204 {
10205    uint8_t ret = ROK;
10206    uint drbIdx=0;
10207    DrbInfo *drbToBeMod;
10208
10209    /*Drb Id */
10210    drbItem->dRBID = DRB2 + arrIdx;
10211
10212    /* Search for DRB ID in CU databse */
10213    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10214    {
10215       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10216       {
10217          drbToBeMod = &ueCb->drbList[drbIdx];
10218          break;
10219       }
10220    }
10221
10222    /*qoSInformation*/
10223    drbItem->qoSInformation = NULLP;
10224    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10225    if(drbItem->qoSInformation != NULLP)
10226    {
10227       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10228
10229       switch(drbItem->qoSInformation->present)
10230       {
10231          case QoSInformation_PR_NOTHING:
10232             {
10233                break;
10234             }
10235          case QoSInformation_PR_eUTRANQoS:
10236             {
10237
10238                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10239                if(drbItem->qoSInformation->choice.eUTRANQoS)
10240                {
10241                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10242                   return RFAILED;
10243                }
10244                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10245                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10246                   PriorityLevel_no_priority;
10247
10248                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10249                   Pre_emptionCapability_may_trigger_pre_emption;
10250
10251                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10252                   Pre_emptionVulnerability_pre_emptable;
10253
10254                break;
10255             }
10256          case QoSInformation_PR_choice_extension:
10257             {
10258                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10259                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10260                {
10261                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10262                   return RFAILED;
10263                }
10264
10265                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10266                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10267                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10268                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10269                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10270                if(ret != ROK)
10271                {
10272                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10273                   return RFAILED;
10274                }
10275
10276                /*SNSSAI*/
10277                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10278                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10279                if(ret != ROK)
10280                {
10281                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10282                   return RFAILED;
10283                }
10284
10285                /*Flows mapped to DRB List*/
10286                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10287                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10288                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10289                if(ret != ROK)
10290                {
10291                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10292                   return RFAILED;
10293                }
10294             }
10295       }
10296    }/* End of QoS */
10297
10298    /*ULUPTNLInformation To Be Setup List*/
10299    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10300             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10301    if(ret != ROK)
10302    {
10303       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10304       return RFAILED;
10305    }
10306    return ROK;
10307 }
10308
10309 /*******************************************************************
10310 *
10311 * @brief Builds the DRB to be modified Item IE
10312 *
10313 * @details
10314 *
10315 *    Function : FillDrbToBeModItemList
10316 *
10317 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10318 *
10319 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10320 *
10321 * @return ROK     - success
10322 *         RFAILED - failure
10323 *
10324 * ****************************************************************/
10325
10326 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10327 {
10328    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10329    drbItemIe->criticality = Criticality_reject;
10330    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10331    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10332    {
10333       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10334       return RFAILED;
10335    }
10336
10337    return ROK;
10338 }
10339
10340 /*******************************************************************
10341 *
10342 * @brief Builds the DRB to be modified list
10343 *
10344 * @details
10345 *
10346 *    Function : BuildDrbToBeModList
10347 *
10348 *    Functionality: Constructs the DRB to be modified list
10349 *
10350 * @params[in] DRBs_ToBeModified_List_t *drbSet
10351 *
10352 * @return ROK     - success
10353 *         RFAILED - failure
10354 *
10355 * ****************************************************************/
10356
10357 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10358 {
10359    uint8_t ret = ROK;
10360    uint8_t arrIdx =0;
10361    uint8_t drbCnt =0;
10362
10363    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10364    drbSet->list.count = drbCnt;
10365    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10366    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10367    if(drbSet->list.array == NULLP)
10368    {
10369       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10370       return  RFAILED;
10371    }
10372    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10373    {
10374       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10375       if(drbSet->list.array[arrIdx] == NULLP)
10376       {
10377          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10378          return  RFAILED;
10379       }
10380
10381       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10382       if(ret != ROK)
10383       {
10384          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10385       }
10386    }
10387
10388    return ret;
10389 }
10390
10391 /*******************************************************************
10392 *
10393 * @brief freeing the DRB  item
10394 *
10395 * @details
10396 *
10397 *    Function : FreeModifiedDrbItem
10398 *
10399 *    Functionality: freeing the DRB 2 item
10400 *
10401 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10402 *
10403 * @return ROK     - success
10404 *         RFAILED - failure
10405 *
10406 * ****************************************************************/
10407
10408 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10409 {
10410    uint8_t arrIdx =0;
10411    SNSSAI_t *snssai =NULLP;
10412    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10413
10414    if(drbItem->qoSInformation != NULLP)
10415    {
10416       switch(drbItem->qoSInformation->present)
10417       {
10418          case QoSInformation_PR_NOTHING:
10419             break;
10420          case QoSInformation_PR_eUTRANQoS:
10421             {
10422                if(drbItem->qoSInformation->choice.eUTRANQoS)
10423                {
10424                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10425                }
10426                break;
10427             }
10428          case QoSInformation_PR_choice_extension:
10429             {
10430                if(drbItem->qoSInformation->choice.choice_extension)
10431                {
10432                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10433
10434                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10435                   if(snssai->sST.buf)
10436                   {
10437                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10438                   }
10439                   if(snssai->sD)
10440                   {
10441                      if(snssai->sD->buf)
10442                      {
10443                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10444                      }
10445                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10446                   }
10447
10448                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10449                   if(flowMap->list.array)
10450                   {
10451                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10452                      {
10453                         if(flowMap->list.array[arrIdx] )
10454                         {
10455                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10456                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10457                         }
10458                      }
10459                      CU_FREE(flowMap->list.array,flowMap->list.size);
10460                   }
10461
10462                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10463                }
10464                break;
10465             }
10466       }
10467    }
10468    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10469    if(drbItem->uLConfiguration)
10470    {
10471       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10472    }
10473 }
10474
10475 /*******************************************************************
10476 *
10477 * @brief free the DRB to be modfified list
10478 *
10479 * @details
10480 *
10481 *    Function : FreeDrbToBeModifiedList
10482 *
10483 *    Functionality: free the DRB to be Setup Mod list
10484 *
10485 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10486 *
10487 * @return ROK     - success
10488 *         RFAILED - failure
10489 *
10490 * ****************************************************************/
10491 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10492 {
10493    uint8_t arrIdx =0;
10494    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10495
10496    if(drbSet->list.array)
10497    {
10498       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10499       {
10500          if(drbSet->list.array[arrIdx] != NULLP)
10501          {
10502             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10503             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10504             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10505          }
10506       }
10507       CU_FREE(drbSet->list.array, drbSet->list.size);
10508    }
10509
10510 }
10511
10512 /*******************************************************************
10513  *
10514  * @brief  free the UeContextModification Request
10515  *
10516  * @details
10517  *
10518  *    Function : FreeUeContextModicationRequest
10519  *
10520  *    Functionality : deallocation of memory allocated in UeContextModiification
10521  request
10522  *
10523  * @params[in] F1AP_PDU_t *f1apMsg
10524  *
10525  * @return void
10526 *
10527 * ****************************************************************/
10528 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10529 {
10530    uint8_t arrIdx =0 , ieId=0;
10531    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10532
10533    if(f1apMsg)
10534    {
10535       if(f1apMsg->choice.initiatingMessage)
10536       {
10537          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10538          if(ueContextModifyReq->protocolIEs.list.array)
10539          {
10540             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10541             {
10542                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10543                {
10544                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10545                   switch(ieId)
10546                   {
10547                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10548                         break;
10549                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10550                         break;
10551                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10552                         {
10553                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10554                                  choice.DRBs_ToBeSetupMod_List);
10555                            break;
10556                         }
10557                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10558                         {
10559                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10560                                  choice.DRBs_ToBeModified_List);
10561                            break;
10562                         }
10563                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10564                         break;
10565                     case ProtocolIE_ID_id_RRCContainer:
10566                     {
10567                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10568                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10569                     }
10570
10571                   }
10572                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10573                }
10574             }
10575             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10576          }
10577          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10578       }
10579       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10580    }
10581 }
10582
10583 /*******************************************************************
10584  *
10585  * @brief Builds the Ue Context Modification Req
10586  *
10587  * @details
10588  *
10589  *    Function : BuildAndSendUeContextModificationReq
10590  *
10591  *    Functionality: Constructs the Ue Context Modification Req
10592  *
10593  * @params[in]
10594  *
10595  * @return ROK     - success
10596  *         RFAILED - failure
10597  *
10598  * ****************************************************************/
10599 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10600 {
10601    uint8_t    ieIdx = 0;
10602    uint8_t    elementCnt = 0;
10603    uint8_t    ret = RFAILED;
10604    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10605    F1AP_PDU_t *f1apMsg = NULLP;
10606    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10607    asn_enc_rval_t         encRetVal;
10608    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10609    while(1)
10610    {
10611       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10612       if(f1apMsg == NULLP)
10613       {
10614          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10615          break;
10616       }
10617
10618       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10619
10620       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10621       if(f1apMsg->choice.initiatingMessage == NULLP)
10622       {
10623          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10624          break;
10625       }
10626       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10627       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10628       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10629
10630       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10631
10632       if(action == MODIFY_UE)
10633          elementCnt = 4;
10634       else if(action == QUERY_CONFIG)
10635          elementCnt = 3;
10636       else if(action == RRC_RECONFIG_COMPLETE_IND)
10637          elementCnt = 3;
10638       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10639          elementCnt = 5;
10640
10641       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10642       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10643
10644       /* Initialize the UE context modification members */
10645       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10646       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10647       {
10648          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10649          break;
10650       }
10651
10652       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10653       {
10654          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10655          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10656          {
10657             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10658             break;
10659          }
10660       }
10661
10662       ieIdx=0;
10663       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10664       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10665       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10666                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10667       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10668
10669       ieIdx++;
10670       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10671       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10672       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10673                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10674       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10675
10676       if(action == MODIFY_UE)
10677       {
10678          /* DRB to be setup list */
10679          ieIdx++;
10680          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10681          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10682          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10683                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10684          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10685                   value.choice.DRBs_ToBeSetupMod_List));
10686
10687          /* DRB to be modified list */
10688          ieIdx++;
10689          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10690          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10691          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10692                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10693          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10694                   value.choice.DRBs_ToBeModified_List));
10695
10696          /* TODO: DRB to be release list */
10697
10698          if(ret != ROK)
10699          {
10700             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
10701             break;
10702          }
10703
10704          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
10705       }
10706       else if(action == QUERY_CONFIG)
10707       {
10708          ieIdx++;
10709          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10710          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10711          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10712             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10713          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10714       }
10715       else if(action == RRC_RECONFIG_COMPLETE_IND)
10716       {
10717          ieIdx++;
10718          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10719          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10720          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10721             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
10722          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
10723             RRCReconfigurationCompleteIndicator_true;
10724       }
10725       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10726       {
10727          ieIdx++;
10728          if(action == STOP_DATA_TX)
10729          {
10730             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10731             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10732             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10733             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10734             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10735             TransmissionActionIndicator_stop;
10736          }
10737          else if (action == RESTART_DATA_TX)
10738          {
10739             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10740             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10741             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10742             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10743             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10744             TransmissionActionIndicator_restart;
10745          }
10746
10747          ieIdx++;
10748          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10749          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10750          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10751          UEContextModificationRequestIEs__value_PR_RRCContainer;
10752          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
10753          {
10754             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
10755             return RFAILED;
10756          }
10757
10758          /* RRC delivery status request */
10759          ieIdx++;
10760          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
10761          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10762          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
10763          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
10764       }
10765
10766       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10767
10768       /* Encode the F1SetupRequest type as APER */
10769       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10770       encBufSize = 0;
10771       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10772
10773       /* Encode results */
10774       if(encRetVal.encoded == ENCODE_FAIL)
10775       {
10776          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
10777                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10778          break;
10779       }
10780       else
10781       {
10782          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
10783 #if 0
10784          /* This for loop was going into an infinite loop even though encBufSize
10785           * has a small value. Hence commented this
10786           */
10787          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10788          {
10789             DU_LOG("%x",encBuf[ieIdx]);
10790          }
10791 #endif
10792       }
10793
10794       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10795       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10796       {
10797          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
10798          break;
10799       }
10800
10801       ret = ROK;
10802       break;
10803
10804    }
10805    FreeUeContextModicationRequest(f1apMsg);
10806    return ret;
10807 }
10808
10809 /*****************************************************************i
10810  *
10811 * @brief Free memory allocated for UE Context Release Command
10812 *
10813 * @details
10814 *
10815 *    Function : FreeUeContextReleaseCommand
10816 *
10817 *    Functionality:
10818 *         - Free memory allocated for UE Context Release Command
10819 *
10820 * @params[in] F1AP_PDU_t *f1apMsg
10821 * @return void
10822 *
10823 * *************************************************************/
10824 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
10825 {
10826    uint8_t ieIdx;
10827    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
10828
10829    if(f1apMsg)
10830    {
10831       if(f1apMsg->choice.initiatingMessage)
10832       {
10833          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10834          if(ueReleaseCommand->protocolIEs.list.array)
10835          {
10836             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
10837             {
10838                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10839             }
10840             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
10841          }
10842          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10843       }
10844       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10845    }
10846 }
10847 /*******************************************************************
10848  *
10849  * @brief Builds the Ue Context Release Command
10850  *
10851  * @details
10852 *
10853 *    Function : BuildAndSendUeContextReleaseCommand
10854 *
10855 *    Functionality: Constructs the Ue Context Release Command
10856 *
10857 * @params[in]
10858 *
10859 * @return ROK     - success
10860 *         RFAILED - failure
10861 *
10862 * ****************************************************************/
10863 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
10864 {
10865    bool       memAllocFailed = false;
10866    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
10867    DuDb *duDb;
10868    CuUeCb *ueCb;
10869    F1AP_PDU_t *f1apMsg = NULLP;
10870    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
10871
10872    asn_enc_rval_t         encRetVal;
10873    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
10874
10875    while(true)
10876    {
10877       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10878       if(f1apMsg == NULLP)
10879       {
10880          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
10881          break;
10882       }
10883
10884       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10885
10886       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10887       if(f1apMsg->choice.initiatingMessage == NULLP)
10888       {
10889          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
10890          break;
10891       }
10892       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
10893       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10894       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
10895
10896       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10897
10898       SEARCH_DU_DB(duIdx, duId, duDb);
10899       ueCb = &duDb->ueCb[duUeF1apId-1];
10900       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
10901          elementCnt = 3;
10902       else
10903          elementCnt = 4;
10904
10905       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
10906       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
10907
10908       /* Initialize the UE context modification members */
10909       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
10910       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
10911       {
10912          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
10913          break;
10914       }
10915
10916       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10917       {
10918          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10919          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
10920          {
10921             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
10922             memAllocFailed = true;
10923             break;
10924          }
10925       }
10926
10927       if(memAllocFailed == true)
10928       {
10929          break;
10930       }
10931
10932       ieIdx=0;
10933       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10934       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10935       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10936       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
10937       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
10938
10939       ieIdx++;
10940       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10941       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10942       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10943       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
10944       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
10945
10946       /* Cause of UE context release */
10947       ieIdx++;
10948       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
10949       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10950       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10951                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
10952       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10953       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
10954                                                                                                      CauseRadioNetwork_normal_release;
10955       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
10956       {
10957          /* RRC Container for RRC release */
10958          ieIdx++;
10959          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10960          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10961          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10962                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
10963          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
10964          bufLen =7;
10965          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
10966          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
10967                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
10968          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
10969          {
10970             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
10971             break;
10972          }
10973          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
10974          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
10975       }
10976       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10977
10978       /* Encode the UE Context Release Command type as APER */
10979       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10980       encBufSize = 0;
10981       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10982             encBuf);
10983
10984       /* Encode results */
10985       if(encRetVal.encoded == ENCODE_FAIL)
10986       {
10987          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
10988                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10989          break;
10990       }
10991       else
10992       {
10993          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
10994          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10995          {
10996             DU_LOG("%x",encBuf[ieIdx]);
10997          }
10998       }
10999
11000       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11001       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11002       {
11003          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11004          break;
11005       }
11006
11007       ret = ROK;
11008       break;
11009
11010    }
11011    FreeUeContextReleaseCommand(f1apMsg);
11012    return ret;
11013 }
11014 /*******************************************************************
11015 *
11016 * @brief process Ue context release request
11017 *
11018 * @details
11019 *
11020 *    Function : procUeContextReleaseReq
11021 *
11022 *    Functionality:
11023 *         - process Ue context release request
11024 *
11025 * @params[in] F1AP_PDU_t *f1apMsg
11026 * @return ROK     - success
11027 *         RFAILED - failure
11028 *
11029 * ****************************************************************/
11030 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11031 {
11032    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11033
11034    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11035    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11036
11037    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11038    {
11039       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11040       {
11041          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11042             {
11043                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11044                break;
11045             }
11046          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11047             {
11048                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11049                break;
11050             }
11051          default:
11052               break;
11053       }
11054    }
11055
11056    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11057    {
11058       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11059       return RFAILED;
11060    }
11061    return ROK;
11062 }
11063 /*******************************************************************
11064 *
11065 * @brief processing of Gnb-DU config update
11066 *
11067 * @details
11068 *
11069 *    Function : procGnbDuUpdate
11070 *
11071 *    Functionality:
11072 *         - processing of Gnb-DU config update
11073 *
11074 * @params[in] F1AP_PDU_t *f1apMsg
11075 * @return ROK     - success
11076 *         RFAILED - failure
11077 *
11078 * ****************************************************************/
11079 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11080 {
11081    bool cellToBeDelete = false;
11082    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11083    uint16_t nrCellId;
11084    DuDb *duDb;
11085    CuCellCb *cellCb;
11086    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11087
11088    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11089    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11090    {
11091       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11092       {
11093          case ProtocolIE_ID_id_TransactionID:
11094             break;
11095          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11096             break;
11097          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11098             {
11099                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11100                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11101                   Served_Cells_To_Delete_List.list.array[0];
11102                nrCellId = deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.buf[4] >>\
11103                   deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.bits_unused;
11104                cellToBeDelete = true;
11105                break;
11106             }
11107          case ProtocolIE_ID_id_gNB_DU_ID:
11108             break;
11109       }
11110    }
11111    if(BuildAndSendDUUpdateAck(duId) != ROK)
11112    {
11113       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11114       return RFAILED;
11115    }
11116 #if 0
11117    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11118     * commented this trigger for now */
11119
11120    if(cellToBeDelete == false)
11121    {
11122       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11123       if(BuildAndSendF1ResetReq() != ROK)
11124       {
11125          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11126          return RFAILED;
11127       }
11128    }
11129 #endif
11130    if(cellToBeDelete == true)
11131    {
11132       SEARCH_DU_DB(duIdx, duId, duDb);
11133       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11134       if(cellCb->numUe == 0)
11135       {
11136          memset(cellCb, 0, sizeof(CuCellCb));
11137          duDb->numCells--;
11138       }
11139       else
11140          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11141    }
11142    return ROK;
11143 }
11144
11145 /*******************************************************************
11146 *
11147 * @brief storing slice list in CU database
11148 *
11149 * @details
11150 *
11151 *    Function : buildSliceList
11152 *
11153 *    Functionality:
11154 *         - storing slice list in CU database
11155 *
11156 * @params[in] SliceSupportList_t *sliceSupportList
11157 * @return ROK     - success
11158 *         RFAILED - failure
11159 *
11160 * ****************************************************************/
11161 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11162 {
11163    uint8_t sliceListIdx = 0;
11164
11165    if(sliceSupportList)
11166    {
11167       if(sliceSupportList->list.array)
11168       {
11169          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11170          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11171          {
11172             if(sliceSupportList->list.array[sliceListIdx])
11173             {
11174                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11175                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11176                {
11177                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11178                    return RFAILED;
11179                }
11180                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11181                {
11182                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11183                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11184                }
11185                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11186                {
11187                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11188                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11189                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11190                }
11191             }
11192          }
11193       }
11194    }
11195    return ROK;
11196 }
11197
11198 /****************************************************************
11199  * @brief Function to process Srb Setup Mod List
11200  *
11201  * @details
11202  *
11203  *    Function : procSrbSetupModList
11204  *
11205  *    Functionality:
11206  *         - Function to process SRB Setup Mod List
11207  *
11208  * @params[in]
11209  * @return ROK     - success
11210  *         RFAILED - failure
11211  *
11212  * ****************************************************************/
11213 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11214 {
11215    uint8_t arrIdx = 0, srbIdx;
11216    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11217
11218    if(srbSetupList != NULLP)
11219    {
11220       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11221       {
11222          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11223          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11224          {
11225             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11226             {
11227                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11228                {
11229                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11230                   break;
11231                }
11232             }
11233          }
11234
11235       }
11236    }
11237    return ROK;
11238 }
11239
11240
11241 /****************************************************************
11242  * @brief Function to process Drb Setup Mod List
11243  *
11244  * @details
11245  *
11246  *    Function : procDrbSetupModList
11247  *
11248  *    Functionality:
11249  *         - Function to process DRB Setup Mod List
11250  *
11251  * @params[in]
11252  * @return ROK     - success
11253  *         RFAILED - failure
11254  *
11255  * ****************************************************************/
11256 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11257 {
11258    uint8_t arrIdx = 0, drbIdx;
11259    uint32_t teId = 0;
11260    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11261
11262    if(drbSetupList != NULLP)
11263    {
11264       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11265       {
11266          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11267          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11268          {
11269             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11270             {
11271                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11272                {
11273                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11274                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11275                   break;
11276                }
11277             }
11278
11279             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11280             {
11281             /* extracting teId */
11282             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11283             if(teId > 0)
11284             {
11285               if(addDrbTunnels(duId, teId)== ROK)
11286               {
11287                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11288               }
11289             }
11290             else
11291                return RFAILED;
11292             }
11293          }
11294       }
11295    }
11296    return ROK;
11297 }
11298
11299 /*******************************************************************
11300 *
11301 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11302 *
11303 * @details
11304 *
11305 *    Function : procServedCellPlmnList
11306 *
11307 *    Functionality:
11308 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11309 *         SNSSAI list
11310 *
11311 * @params[in] F1AP_PDU_t *f1apMsg
11312 * @return ROK     - success
11313 *         RFAILED - failure
11314 *
11315 * ****************************************************************/
11316 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11317 {
11318    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11319    ProtocolExtensionContainer_4624P3_t **ieExtend;
11320
11321    if(srvPlmn->list.array)
11322    {
11323       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11324       {
11325          if(srvPlmn->list.array[srvPlmnIdx])
11326          {
11327             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11328             if(*ieExtend)
11329             {
11330                if((*ieExtend)->list.array)
11331                {
11332                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11333                   {
11334                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11335                      {
11336                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11337                         {
11338                            case ProtocolIE_ID_id_TAISliceSupportList:
11339                               {
11340                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11341                                           extensionValue.choice.SliceSupportList) != ROK)
11342                                  {
11343                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11344                                     return RFAILED;
11345                                  }
11346                               }
11347                         }
11348                      }
11349                   }
11350                }
11351             }
11352          }
11353       }
11354    }
11355    return ROK;
11356 }
11357
11358 /****************************************************************
11359  * @brief Function to process Ue Context Modification Response
11360  *
11361  * @details
11362  *
11363  *    Function : procUeContextModificationResponse
11364  *
11365  *    Functionality:
11366  *         - Function to process Ue Context Modification Response
11367  *
11368  * @params[in]
11369  * @return ROK     - success
11370  *         RFAILED - failure
11371  *
11372  * ****************************************************************/
11373 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11374 {
11375    uint8_t idx=0, duIdx=0;
11376    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11377    DuDb *duDb = NULLP;
11378    CuUeCb *ueCb = NULLP;
11379    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11380
11381    SEARCH_DU_DB(duIdx, duId, duDb);
11382    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11383
11384    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11385    {
11386       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11387       {
11388           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11389              {
11390                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11391                 break;
11392              }
11393           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11394              {
11395                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11396                 ueCb = &duDb->ueCb[duUeF1apId-1];
11397                 break;
11398              }
11399           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11400              {
11401                 /* Adding Tunnels for successful DRB */
11402                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11403                 break;
11404
11405              }
11406           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11407              {
11408                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11409                 break;
11410              }
11411          case ProtocolIE_ID_id_DUtoCURRCInformation:
11412              {
11413                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11414                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11415                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11416                 {
11417                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11418                    return RFAILED;
11419                 }
11420                 break;
11421              }
11422
11423       }
11424    }
11425
11426    /* If UE is in handover and UE context is not yet created at target DU, then send
11427     * UE context setup request to target DU */
11428    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11429    {
11430       uint8_t ueIdx = 0;
11431       DuDb *tgtDuDb = NULLP;
11432       CuUeCb *ueCbInTgtDu = NULLP;
11433
11434       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11435       if(tgtDuDb)
11436       {
11437          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11438           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11439           * DB */
11440          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11441          {
11442             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11443             {
11444                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11445                break;
11446             }
11447          }
11448
11449          /* If UE context is not found in Target DU DU, send UE context setup
11450           * request */
11451          if(ueCbInTgtDu == NULLP)
11452          {
11453             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb, 0, NULLP)) != ROK)
11454             {
11455                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11456                return RFAILED;
11457             }
11458          }
11459       }
11460    }
11461
11462    return ROK;
11463 }
11464
11465 /*******************************************************************
11466 *
11467 * @brief processing of F1 setup request
11468 *
11469 * @details
11470 *
11471 *    Function : procF1SetupReq
11472 *
11473 *    Functionality:
11474 *         - processing of  F1 setup request
11475 *
11476 * @params[in] F1AP_PDU_t *f1apMsg
11477 * @return ROK     - success
11478 *         RFAILED - failure
11479 *
11480 * ****************************************************************/
11481 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11482 {
11483    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11484    uint32_t duId = 0, nrCellId = 0;
11485    DuDb     *duDb = NULLP;
11486    CuCellCb *cellCb = NULLP;
11487    BIT_STRING_t nrcellIdentity;
11488    F1SetupRequest_t *f1SetupReq = NULLP;
11489    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11490    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11491
11492    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11493    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11494    {
11495       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11496       {
11497          case ProtocolIE_ID_id_gNB_DU_ID:
11498            {
11499               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11500               SEARCH_DU_DB(duIdx, duId, duDb);
11501               if(duDb == NULLP)
11502               {
11503                  duDb = &cuCb.duInfo[cuCb.numDu];
11504                  memset(duDb, 0, sizeof(DuDb));
11505                  duDb->duId = duId;
11506                  cuCb.numDu++;
11507                  *destDuId = duId;
11508               }
11509               else
11510                  return;
11511               break;
11512            }
11513          case ProtocolIE_ID_id_gNB_DU_Name:
11514            {
11515               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11516               break;
11517            }
11518          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11519            {
11520                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11521                if(duServedCell->list.array)
11522                {
11523                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11524                   {
11525                      if(duServedCell->list.array[plmnidx])
11526                      {
11527                         switch(duServedCell->list.array[plmnidx]->id)
11528                         {
11529                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11530                            {
11531                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11532                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11533                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11534
11535                               nrCellId = nrcellIdentity.buf[4] >> nrcellIdentity.bits_unused;
11536                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11537                               if(cellCb == NULLP)
11538                               {
11539                                  cellCb = &duDb->cellCb[duDb->numCells];
11540                                  memset(cellCb, 0, sizeof(CuCellCb));
11541                                  cellCb->nrCellId = nrCellId;
11542                                  cellCb->cellStatus = CELL_ACTIVE;
11543                                  duDb->numCells++;
11544                               }
11545                            }
11546                         }
11547                      }
11548                   }
11549                }
11550            }
11551       }
11552    }
11553    if(ret == ROK)
11554    {
11555       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11556    }
11557    else
11558    {
11559        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11560    }
11561 }
11562
11563 /****************************************************************
11564 *
11565 * @brief processing of UE Context Release Complete
11566 *
11567 * @details
11568 *
11569 *    Function : procUeContextReleaseComplete
11570 *
11571 *    Functionality:
11572 *         - processing of UE Context Release Complete
11573 *
11574 * @params[in] F1AP_PDU_t *f1apMsg
11575 * @return ROK     - success
11576 *         RFAILED - failure
11577 *
11578 * ****************************************************************/
11579 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11580 {
11581    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0;
11582    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11583    DuDb *duDb = NULLP;
11584    CuUeCb *ueCb = NULLP;
11585    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11586
11587    SEARCH_DU_DB(duIdx, duId, duDb);
11588    if(!duDb)
11589    {
11590       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11591       return;
11592    }
11593
11594    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11595    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11596    {
11597       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11598       {
11599          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11600             {
11601                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11602                break;
11603             }
11604          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11605             {
11606                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11607                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11608                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11609                {
11610                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11611                   {
11612                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11613                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11614                      {
11615                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11616                         ueCb->cellCb->numUe--;
11617                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus = CELL_DELETION_IN_PROGRESS))
11618                         {
11619                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11620                            duDb->numCells--;
11621                         }
11622                         break;
11623                      }
11624                   }
11625                }
11626                memset(ueCb, 0, sizeof(CuUeCb));
11627                duDb->numUe--;
11628                break;
11629             }
11630       }
11631    }
11632 }
11633
11634 /*******************************************************************
11635  *
11636  * @brief Builds the Paging cell list
11637  *
11638  * @details
11639  *
11640  *    Function : BuildPagingCellList
11641  *
11642  *    Functionality: Build the paging cell list
11643  *
11644  * @params[in] PagingCell_list_t  *pagingCelllist,
11645  *
11646  * @return ROK     - success
11647  *         RFAILED - failure
11648  *
11649  * ****************************************************************/
11650 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11651 {
11652    uint8_t cellIdx =0;
11653    PagingCell_ItemIEs_t *pagingCellItemIes;
11654    PagingCell_Item_t *pagingCellItem;
11655
11656    pagingCelllist->list.count = numCells;
11657    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11658    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11659    if(pagingCelllist->list.array == NULLP)
11660    {
11661       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11662       return RFAILED;
11663    }
11664
11665    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11666    {
11667       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11668       if(pagingCelllist->list.array[cellIdx] == NULLP)
11669       {
11670          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11671          return RFAILED;
11672       }
11673    }
11674
11675    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11676    {
11677       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11678       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
11679       pagingCellItemIes->criticality = Criticality_ignore;
11680       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
11681       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11682
11683       /* Fill NrCgi Information */
11684       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
11685    }
11686
11687    return ROK;
11688 }
11689
11690 /*******************************************************************
11691  *
11692  * @brief Deallocation of memory allocated in paging msg
11693  *
11694  * @details
11695  *
11696  *    Function :FreePagingMsg
11697  *
11698  *    Functionality: Deallocation of memory allocated in paging msg
11699  *
11700  * @params[in] F1AP_PDU_t *f1apMsg
11701  *
11702  * @return void
11703  *
11704  * ****************************************************************/
11705 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
11706 {
11707    uint8_t ieIdx, cellIdx;
11708    Paging_t   *paging;
11709    PagingCell_ItemIEs_t *pagingCellItemIes;
11710    PagingCell_Item_t *pagingCellItem;
11711    PagingCell_list_t  *pagingCelllist;
11712
11713    if(f1apMsg)
11714    {
11715       if(f1apMsg->choice.initiatingMessage)
11716       {
11717          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11718          if(paging->protocolIEs.list.array)
11719          {
11720             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
11721             {
11722                if(paging->protocolIEs.list.array[ieIdx])
11723                {
11724                   switch(paging->protocolIEs.list.array[ieIdx]->id)
11725                   {
11726                      case ProtocolIE_ID_id_UEIdentityIndexValue:
11727                      {
11728                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11729                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11730                         break;
11731                      }
11732
11733                      case ProtocolIE_ID_id_PagingIdentity:
11734                      {
11735                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
11736                         {
11737                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11738                            {
11739                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
11740                               {
11741                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11742                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11743                               }
11744                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
11745                                 sizeof(struct CNUEPagingIdentity));
11746                            }
11747                         }
11748                         break;
11749                      }
11750
11751                      case ProtocolIE_ID_id_PagingCell_List:
11752                      {
11753                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
11754                         if(pagingCelllist->list.array)
11755                         {
11756                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11757                            {
11758                               if(pagingCelllist->list.array[cellIdx])
11759                               {
11760                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11761                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
11762                                   {
11763                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11764                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
11765                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
11766                                   }
11767                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11768                               }
11769                            }
11770                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
11771                         }
11772                         break;
11773                      }
11774                   }
11775                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11776                }
11777             }
11778             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11779          }
11780          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11781       }
11782       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11783    }
11784 }
11785 /*******************************************************************
11786  *
11787  * @brief Builds and sends the paging message if UE is in idle mode
11788  *
11789  * @details
11790  *
11791  *    Function : BuildAndSendPagingMsg
11792  *
11793  *    Functionality: Builds and sends the paging message
11794  *
11795  * @params[in] uint32_t duId, uint8_t gsTmsi
11796  *
11797  * @return ROK     - success
11798  *         RFAILED - failure
11799  *
11800  * ****************************************************************/
11801 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
11802 {
11803    bool       memAllocFailed = false;
11804    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
11805    uint16_t   ueId = 0, duIdx = 0;
11806
11807    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
11808     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
11809    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
11810    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
11811
11812    F1AP_PDU_t *f1apMsg = NULLP;
11813    Paging_t   *paging = NULLP;
11814    DuDb       *duDb;
11815    asn_enc_rval_t         encRetVal;
11816
11817    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
11818
11819    SEARCH_DU_DB(duIdx, duId, duDb);
11820    if(duDb == NULLP)
11821    {
11822       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
11823       return ret;
11824    }
11825
11826    while(true)
11827    {
11828       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11829       if(f1apMsg == NULLP)
11830       {
11831          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
11832          break;
11833       }
11834
11835       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11836
11837       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11838       if(f1apMsg->choice.initiatingMessage == NULLP)
11839       {
11840          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
11841          break;
11842       }
11843       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
11844       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11845       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
11846
11847       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11848
11849       elementCnt = 5;
11850       paging->protocolIEs.list.count = elementCnt;
11851       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
11852
11853       /* Initialize the Paging Message members */
11854       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11855       if(paging->protocolIEs.list.array == NULLP)
11856       {
11857          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
11858          break;
11859       }
11860
11861       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11862       {
11863          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11864          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
11865          {
11866             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11867             memAllocFailed = true;
11868             break;
11869          }
11870       }
11871
11872       if(memAllocFailed == true)
11873       {
11874          break;
11875       }
11876
11877       /* UE Identity Index Value */
11878       ieIdx=0;
11879       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
11880       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11881       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
11882       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
11883       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
11884       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11885             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11886       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
11887       {
11888          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11889          break;
11890       }
11891
11892       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
11893       ueId = gsTmsi % 1024;
11894       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
11895
11896       /* Paging Identity */
11897       ieIdx++;
11898       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
11899       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11900       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
11901       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
11902                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
11903       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
11904             sizeof(struct CNUEPagingIdentity));
11905       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11906       {
11907          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11908          break;
11909       }
11910
11911       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
11912                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
11913
11914       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
11915       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11916             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11917       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
11918       {
11919          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11920          break;
11921       }
11922
11923       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
11924             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
11925
11926       /* Paging Drx */
11927       ieIdx++;
11928       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
11929       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11930       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
11931       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
11932
11933       /* Paging Priority */
11934       ieIdx++;
11935       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
11936       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11937       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
11938       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
11939
11940       /* Paging Cell List */
11941       ieIdx++;
11942       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
11943       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11944       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
11945       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
11946       {
11947          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
11948          break;
11949       }
11950
11951       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11952
11953       /* Encode the UE Context Release Command type as APER */
11954       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11955       encBufSize = 0;
11956       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11957             encBuf);
11958
11959       /* Encode results */
11960       if(encRetVal.encoded == ENCODE_FAIL)
11961       {
11962          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11963                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11964          break;
11965       }
11966       else
11967       {
11968          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
11969          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11970          {
11971             DU_LOG("%x",encBuf[ieIdx]);
11972          }
11973       }
11974
11975       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11976       {
11977          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11978          break;
11979       }
11980
11981       ret = ROK;
11982       break;
11983
11984    }
11985
11986    FreePagingMsg(f1apMsg);
11987    return ret;
11988 }
11989
11990 /*******************************************************************
11991  *
11992  * @brief Handles received F1AP message and sends back response
11993  *
11994  * @details
11995  *
11996  *    Function : F1APMsgHdlr
11997  *
11998  *    Functionality:
11999  *         - Decodes received F1AP control message
12000  *         - Prepares response message, encodes and sends to SCTP
12001  *
12002  * @params[in]
12003  * @return ROK     - success
12004  *         RFAILED - failure
12005  *
12006  * ****************************************************************/
12007 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12008 {
12009    int i;
12010    char *recvBuf;
12011    MsgLen copyCnt;
12012    MsgLen recvBufLen;
12013    F1AP_PDU_t *f1apMsg = NULLP;
12014    asn_dec_rval_t rval; /* Decoder return value */
12015    F1AP_PDU_t f1apasnmsg ;
12016
12017    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12018    ODU_PRINT_MSG(mBuf, 0,0);
12019
12020    /* Copy mBuf into char array to decode it */
12021    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12022    CU_ALLOC(recvBuf, (Size)recvBufLen);
12023
12024    if(recvBuf == NULLP)
12025    {
12026       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12027       return;
12028    }
12029    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12030    {
12031       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12032       return;
12033    }
12034
12035    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12036    for(i=0; i< recvBufLen; i++)
12037    {
12038       DU_LOG("%x",recvBuf[i]);
12039    }
12040
12041    /* Decoding flat buffer into F1AP messsage */
12042    f1apMsg = &f1apasnmsg;
12043    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12044
12045    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12046    CU_FREE(recvBuf, (Size)recvBufLen);
12047
12048    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12049    {
12050       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12051       return;
12052    }
12053    DU_LOG("\n");
12054    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12055
12056    switch(f1apMsg->present)
12057    {
12058       case F1AP_PDU_PR_initiatingMessage:
12059          {
12060             switch(f1apMsg->choice.initiatingMessage->value.present)
12061             {
12062                case InitiatingMessage__value_PR_Reset:
12063                   {
12064                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12065                      BuildAndSendF1ResetAck();
12066                      break;
12067                   }
12068
12069                case InitiatingMessage__value_PR_F1SetupRequest:
12070                   {
12071                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12072                      procF1SetupReq(duId, f1apMsg);
12073                      break;
12074                   }
12075
12076                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12077                   {
12078                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12079                      procGnbDuUpdate(*duId, f1apMsg);
12080                      break;
12081                   }
12082                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12083                   {
12084                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12085                      procInitULRRCMsg(*duId, f1apMsg);
12086                      break;
12087                   }
12088                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12089                   {
12090                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12091                      procUlRrcMsg(*duId, f1apMsg);
12092                      break;
12093                   }
12094
12095                case InitiatingMessage__value_PR_RRCDeliveryReport:
12096                   {
12097                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12098                      break;
12099                   }
12100                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12101                   {
12102                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12103                      procUeContextReleaseReq(*duId, f1apMsg);
12104                      break;
12105                   }
12106                default:
12107                   {
12108                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12109                            f1apMsg->choice.initiatingMessage->value.present);
12110                      return;
12111                   }
12112             }/* End of switch(initiatingMessage) */
12113             break;
12114          }
12115
12116       case F1AP_PDU_PR_successfulOutcome:
12117          {
12118             switch(f1apMsg->choice.successfulOutcome->value.present)
12119             {
12120                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12121                   {
12122                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12123                      break;
12124                   }
12125                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12126                   {
12127                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12128                      procUeContextSetupResponse(*duId, f1apMsg);
12129                      break;
12130                   }
12131                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12132                   {
12133                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12134                      procUeContextModificationResponse(*duId, f1apMsg);
12135                      break;
12136                   }
12137                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12138                   {
12139                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12140                       procUeContextReleaseComplete(*duId, f1apMsg);
12141                       break;
12142                   }
12143                default:
12144                   {
12145                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12146                            f1apMsg->choice.successfulOutcome->value.present);
12147                      return;
12148                   }
12149             }/* End of switch(successfulOutcome) */
12150             break;
12151          }
12152       default:
12153          {
12154             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12155             return;
12156          }
12157    }/* End of switch(f1apMsg->present) */
12158
12159 } /* End of F1APMsgHdlr */
12160
12161 /**********************************************************************
12162   End of file
12163  **********************************************************************/