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