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 #include "UL-DCCH-Message.h"
 133
 134 #include "cu_stub_sctp.h"
 135 #include "cu_stub_egtp.h"
 136 #include "cu_f1ap_msg_hdl.h"
 137 #include "cu_stub.h"
 138
 139 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 140 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 141
 142 /*******************************************************************
 143  *
 144  * @brief Sends F1 msg over SCTP
 145  *
 146  * @details
 147  *
 148  *    Function : SendF1APMsg
 149  *
 150  *    Functionality: Sends F1 msg over SCTP
 151  *
 152  * @params[in] Region region
 153  *             Pool pool
 154  * @return ROK     - success
 155  *         RFAILED - failure
 156  *
 157  * ****************************************************************/
 158 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 159 {
 160    Buffer *mBuf = NULLP;
 161
 162    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 163    {
 164       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 165       {
 166          ODU_PRINT_MSG(mBuf, 0,0);
 167
 168          if(sctpSend(duId, mBuf) != ROK)
 169          {
 170             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 171             ODU_PUT_MSG_BUF(mBuf);
 172             return RFAILED;
 173          }
 174       }
 175       else
 176       {
 177          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 178          ODU_PUT_MSG_BUF(mBuf);
 179          return RFAILED;
 180       }
 181       ODU_PUT_MSG_BUF(mBuf);
 182    }
 183    else
 184    {
 185       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 186       return RFAILED;
 187    }
 188
 189    return ROK;
 190 } /* SendF1APMsg */
 191
 192 /********************************************************************
 193  *
 194  * @brief Builds and sends the F1SetupResponse
 195  *
 196  * @details
 197  *
 198  *    Function : BuildAndSendF1SetupRsp
 199  *
 200  *    Functionality: Constructs the F1SetupResponse message and sends
 201  *                   it back to the DU through SCTP.
 202  *
 203  * @params[in] void **buf,Buffer to which encoded pattern is written into
 204  * @params[in] int *size,size of buffer
 205  *
 206  * @return ROK     - success
 207  *         RFAILED - failure
 208  *
 209  * ****************************************************************/
 210 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 211 {
 212    uint8_t    idx,ieIdx;
 213    uint8_t    elementCnt,cellCnt;
 214    F1AP_PDU_t         *f1apMsg = NULL;
 215    F1SetupResponse_t  *f1SetupRsp;
 216    GNB_CU_Name_t      *cuName;
 217    Cells_to_be_Activated_List_t *cellToActivate;
 218    RRC_Version_t      *rrcVer;
 219    asn_enc_rval_t     encRetVal;
 220    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 221
 222    /* Allocate the memory for F1SetupRequest_t */
 223    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 224    if(f1apMsg == NULLP)
 225    {
 226       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 227       return RFAILED;
 228    }
 229    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 230
 231    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 232    if(f1apMsg->choice.successfulOutcome == NULLP)
 233    {
 234       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 235       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 236       return RFAILED;
 237    }
 238
 239    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 240    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 241    f1apMsg->choice.successfulOutcome->value.present = \
 242                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 243    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 244
 245    elementCnt = 4;
 246    f1SetupRsp->protocolIEs.list.count = elementCnt;
 247    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 248
 249    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 250          elementCnt * sizeof(F1SetupResponseIEs_t *));
 251    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 252    {
 253       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 254       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 255       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 256       return RFAILED;
 257    }
 258
 259    for(idx=0; idx<elementCnt; idx++)
 260    {
 261       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 262             sizeof(F1SetupResponseIEs_t));
 263       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 264       {
 265          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 266                elementCnt * sizeof(F1SetupResponseIEs_t *));
 267          CU_FREE(f1apMsg->choice.successfulOutcome, \
 268                sizeof(SuccessfulOutcome_t));
 269          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 270          return RFAILED;
 271       }
 272    }
 273
 274    /*TransactionID*/
 275    idx = 0;
 276    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 277    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 278    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 279                                                             F1SetupResponseIEs__value_PR_TransactionID;
 280    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 281                                                                         TRANS_ID;
 282
 283    /*CU Name*/
 284    idx++;
 285    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 286    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 287    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 288                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 289    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 290    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 291
 292    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 293    if(cuName->buf == NULLP)
 294    {
 295       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 296       {
 297          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 298                sizeof(F1SetupResponseIEs_t));
 299       }
 300       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 301             elementCnt * sizeof(F1SetupResponseIEs_t *));
 302       CU_FREE(f1apMsg->choice.successfulOutcome,\
 303             sizeof(SuccessfulOutcome_t));
 304       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 305       return RFAILED;
 306    }
 307    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 308
 309    /*Cells to be activated list*/
 310    idx++;
 311    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 312                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 313    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 314    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 315                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 316    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 317                     Cells_to_be_Activated_List;
 318    cellCnt=1;
 319    cellToActivate->list.count = cellCnt;
 320    cellToActivate->list.size = \
 321                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 322    CU_ALLOC(cellToActivate->list.array,\
 323          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 324    if(cellToActivate->list.array == NULLP)
 325    {
 326       CU_FREE(cuName->buf, sizeof(cuName->size));
 327       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 328       {
 329          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 330                sizeof(F1SetupResponseIEs_t));
 331       }
 332       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 333             elementCnt * sizeof(F1SetupResponseIEs_t *));
 334       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 335       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 336       return RFAILED;
 337    }
 338    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 339    {
 340       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 341       if(cellToActivate->list.array[ieIdx] == NULLP)
 342       {
 343          CU_FREE(cellToActivate->list.array,\
 344                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 345          CU_FREE(cuName->buf, sizeof(cuName->size));
 346          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 347          {
 348             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 349                   sizeof(F1SetupResponseIEs_t));
 350          }
 351          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 352                elementCnt * sizeof(F1SetupResponseIEs_t *));
 353          CU_FREE(f1apMsg->choice.successfulOutcome, \
 354                sizeof(SuccessfulOutcome_t));
 355          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 356          return RFAILED;
 357       }
 358    }
 359    cellToActivate->list.array[0]->id = \
 360                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 361    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 362    cellToActivate->list.array[0]->value.present = \
 363                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 364    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 365       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 366    CU_ALLOC(cellToActivate->list.array[0]->\
 367          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 368          3*sizeof(uint8_t));
 369    if(cellToActivate->list.array[0]->value.choice.\
 370          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 371    {
 372
 373       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 374       {
 375          CU_FREE(cellToActivate->list.array[ieIdx],\
 376                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 377       }
 378
 379       CU_FREE(cellToActivate->list.array,\
 380             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 381       CU_FREE(cuName->buf, sizeof(cuName->size));
 382       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 383       {
 384          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 385                sizeof(F1SetupResponseIEs_t));
 386       }
 387       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 388             elementCnt * sizeof(F1SetupResponseIEs_t *));
 389       CU_FREE(f1apMsg->choice.successfulOutcome, \
 390             sizeof(SuccessfulOutcome_t));
 391       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 392       return RFAILED;
 393    }
 394    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 395          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 396    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 397       nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
 398    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 399          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 400          cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 401          nRCGI.nRCellIdentity.size);
 402    if(cellToActivate->list.array[0]->value.choice.\
 403          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 404    {
 405       CU_FREE(cellToActivate->list.array[0]->\
 406             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 407             3*sizeof(uint8_t));
 408       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 409       {
 410          CU_FREE(cellToActivate->list.array[ieIdx],\
 411                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 412       }
 413
 414       CU_FREE(cellToActivate->list.array,\
 415             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 416       CU_FREE(cuName->buf, sizeof(cuName->size));
 417       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 418       {
 419          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 420                sizeof(F1SetupResponseIEs_t));
 421       }
 422       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 423             elementCnt * sizeof(F1SetupResponseIEs_t *));
 424       CU_FREE(f1apMsg->choice.successfulOutcome, \
 425             sizeof(SuccessfulOutcome_t));
 426       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 427       return RFAILED;
 428    }
 429    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 430    /* RRC Version */
 431    idx++;
 432    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 433                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 434    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 435    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 436                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 437    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 438    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 439
 440    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 441    if(rrcVer->latest_RRC_Version.buf == NULLP)
 442    {
 443       CU_FREE(cuName->buf, sizeof(cuName->size));
 444       for(ieIdx=0; ieIdx<elementCnt; idx++)
 445       {
 446          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 447                sizeof(F1SetupResponseIEs_t));
 448       }
 449       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 450             elementCnt * sizeof(F1SetupResponseIEs_t *));
 451       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 452       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 453       return RFAILED;
 454    }
 455
 456    /* Need to check RRC Version */
 457    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 458    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 459    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 460    if(rrcVer->iE_Extensions == NULLP)
 461    {
 462       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 463       CU_FREE(cuName->buf, sizeof(cuName->size));
 464       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 465       {
 466          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 467                sizeof(F1SetupResponseIEs_t));
 468       }
 469       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 470             elementCnt * sizeof(F1SetupResponseIEs_t *));
 471       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 472       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 473       return RFAILED;
 474    }
 475    rrcVer->iE_Extensions->list.count = 1;
 476    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 477    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 478          sizeof(struct RRC_Version_ExtIEs *));
 479    if(rrcVer->iE_Extensions->list.array == NULLP)
 480    {
 481       CU_FREE(rrcVer->iE_Extensions,\
 482             sizeof(ProtocolExtensionContainer_4624P81_t));
 483       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 484       CU_FREE(cuName->buf, sizeof(cuName->size));
 485       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 486       {
 487          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 488                sizeof(F1SetupResponseIEs_t));
 489       }
 490       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 491             elementCnt * sizeof(F1SetupResponseIEs_t *));
 492       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 493       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 494       return RFAILED;
 495    }
 496    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 497          sizeof(struct RRC_Version_ExtIEs));
 498    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 499    {
 500       CU_FREE(rrcVer->iE_Extensions->list.array,\
 501             sizeof(struct RRC_Version_ExtIEs *));
 502       CU_FREE(rrcVer->iE_Extensions,\
 503             sizeof(ProtocolExtensionContainer_4624P81_t));
 504       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 505       CU_FREE(cuName->buf, sizeof(cuName->size));
 506       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 507       {
 508          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 509                sizeof(F1SetupResponseIEs_t));
 510       }
 511       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 512             elementCnt * sizeof(F1SetupResponseIEs_t *));
 513       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 514       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 515       return RFAILED;
 516    }
 517    rrcVer->iE_Extensions->list.array[0]->id = \
 518                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 519    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 520    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 521                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 522    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 523       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 524    CU_ALLOC(rrcVer->iE_Extensions->list.\
 525          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 526          3*sizeof(uint8_t));
 527    if(rrcVer->iE_Extensions->list.\
 528          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 529    {
 530       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 531             sizeof(struct RRC_Version_ExtIEs));
 532       CU_FREE(rrcVer->iE_Extensions->list.array,\
 533             sizeof(struct RRC_Version_ExtIEs *));
 534       CU_FREE(rrcVer->iE_Extensions,\
 535             sizeof(ProtocolExtensionContainer_4624P81_t));
 536       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 537       CU_FREE(cuName->buf, sizeof(cuName->size));
 538       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 539       {
 540          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 541                sizeof(F1SetupResponseIEs_t));
 542       }
 543       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 544             elementCnt * sizeof(F1SetupResponseIEs_t *));
 545       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 546       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 547       return RFAILED;
 548    }
 549    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 550       Latest_RRC_Version_Enhanced.buf[0] = 0;
 551    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 552       Latest_RRC_Version_Enhanced.buf[1] = 5;
 553    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 554       Latest_RRC_Version_Enhanced.buf[2] = 15;
 555
 556    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 557
 558    /* Encode the F1SetupRequest type as UPER */
 559    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 560    encBufSize = 0;
 561    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 562
 563    /* Clean up */
 564    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 565    CU_FREE(cuName->buf, sizeof(cuName->size));
 566    for(idx=0; idx<elementCnt; idx++)
 567    {
 568       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 569    }
 570    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 571    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 572    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 573
 574    /* Check encode results */
 575    if(encRetVal.encoded == ENCODE_FAIL)
 576    {
 577       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 578             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 579       return RFAILED;
 580    }
 581    else
 582    {
 583       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 584       for(int i=0; i< encBufSize; i++)
 585       {
 586          DU_LOG("%x",encBuf[i]);
 587       }
 588    }
 589
 590    /* Sending msg */
 591    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 592    {
 593       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 594       return RFAILED;
 595    }
 596
 597    return ROK;
 598 }/* End of BuildAndSendF1SetupRsp */
 599
 600 /*******************************************************************
 601  *
 602  * @brief Builds and sends the DUUpdateAcknowledge
 603  *
 604  * @details
 605  *
 606  *    Function : BuildAndSendDUUpdateAck
 607  *
 608  *    Functionality: Constructs the DU Update Acknowledge message and sends
 609  *                   it to the DU through SCTP.
 610  *
 611  * @params[in]
 612  *
 613  * @return ROK     - success
 614  *         RFAILED - failure
 615  *
 616  * ****************************************************************/
 617
 618 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 619 {
 620    uint8_t   idx;
 621    uint8_t   elementCnt;
 622    F1AP_PDU_t *f1apMsg = NULL;
 623    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 624    asn_enc_rval_t enRetVal; /* Encoder return value */
 625
 626    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 627
 628    /* Allocate the memory for F1SetupRequest_t */
 629    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 630    if(f1apMsg == NULLP)
 631    {
 632       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 633       return RFAILED;
 634    }
 635
 636    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 637
 638    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 639    if(f1apMsg->choice.successfulOutcome == NULLP)
 640    {
 641       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 642       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 643       return RFAILED;
 644    }
 645
 646    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 647    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 648    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 649    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 650
 651    elementCnt = 1;
 652    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 653    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 654
 655    /* Initialize the F1Setup members */
 656    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 657    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 658    {
 659       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 660       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 661       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 662       return RFAILED;
 663    }
 664
 665    for(idx=0; idx<elementCnt; idx++)
 666    {
 667       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 668       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 669       {
 670          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 671          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 672          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 673          return RFAILED;
 674       }
 675    }
 676
 677    /*TransactionID*/
 678    idx = 0;
 679    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 680    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 681    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 682    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 683    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 684
 685    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 686
 687    /* Encode the F1SetupRequest type as UPER */
 688    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 689    encBufSize = 0;
 690    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 691
 692    /* Clean up */
 693    for(idx=0; idx<elementCnt; idx++)
 694    {
 695       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 696    }
 697    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 698    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 699    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 700
 701    /* Checking encode results */
 702    if(enRetVal.encoded == ENCODE_FAIL)
 703    {
 704       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 705       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 706       return RFAILED;
 707    }
 708    else
 709    {
 710       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 711       for(int i=0; i< encBufSize; i++)
 712       {
 713          DU_LOG("%x",encBuf[i]);
 714       }
 715    }
 716
 717    /* Sending msg */
 718    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 719    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 720    {
 721       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 722       return RFAILED;
 723    }
 724
 725    return ROK;
 726
 727 }/* End of BuildAndSendDUUpdateAck*/
 728
 729 /*******************************************************************
 730 *
 731 * @brief deallocating the memory of  F1reset msg
 732 *
 733 * @details
 734 *
 735 *    Function : FreeF1ResetReq
 736 *
 737 *    Functionality :
 738 *         - freeing memory of F1reset request msg
 739 *
 740 * @params[in]
 741 * @return void
 742 *
 743 *
 744 * ****************************************************************/
 745 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 746 {
 747    uint8_t idx = 0;
 748    Reset_t *f1ResetMsg = NULLP;
 749
 750    if(f1apMsg)
 751    {
 752       if(f1apMsg->choice.initiatingMessage)
 753       {
 754          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 755          if(f1ResetMsg->protocolIEs.list.array)
 756          {
 757             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 758             {
 759                if(f1ResetMsg->protocolIEs.list.array[idx])
 760                {
 761                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 762                }
 763             }
 764             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 765          }
 766          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 767       }
 768       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 769    }
 770 }
 771 /*******************************************************************
 772  *
 773  * @brief build ansld ans send f1reset msg
 774  *
 775  * @details
 776  *
 777  *    Function : BuildAndSendF1ResetReq
 778  *
 779  *    Functionality: build and send f1reset msg
 780  *
 781  * @return ROK     - success
 782  *         RFAILED - failure
 783  *
 784  * ****************************************************************/
 785 uint8_t BuildAndSendF1ResetReq()
 786 {
 787    uint8_t          elementCnt=0;
 788    uint8_t          idx=0;
 789    uint8_t          ret= RFAILED;
 790    Reset_t          *f1ResetMsg = NULLP;
 791    F1AP_PDU_t       *f1apMsg = NULLP;
 792    asn_enc_rval_t   encRetVal;
 793    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 794    do
 795    {
 796       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 797       if(f1apMsg == NULLP)
 798       {
 799          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 800          break;
 801       }
 802       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 803       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 804       if(f1apMsg->choice.initiatingMessage == NULLP)
 805       {
 806          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 807          break;
 808       }
 809       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 810       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 811       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 812
 813       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 814
 815       elementCnt = 3;
 816       f1ResetMsg->protocolIEs.list.count = elementCnt;
 817       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 818
 819       /* Initialize the F1Reset members */
 820       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 821       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 822       {
 823          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 824          break;
 825       }
 826       for(idx=0; idx<elementCnt; idx++)
 827       {
 828          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 829          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 830          {
 831             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 832             break;
 833          }
 834       }
 835
 836       /*TransactionID*/
 837       idx=0;
 838       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 839       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 840       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 841       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 842
 843       /*Cause*/
 844       idx++;
 845       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 846       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 847       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 848       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 849       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 850
 851       /*Reset Type*/
 852       idx++;
 853       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 854       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 855       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 856       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 857       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 858
 859       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 860
 861       /* Encode the F1SetupRequest type as APER */
 862       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 863       encBufSize = 0;
 864       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 865             encBuf);
 866
 867       /* Encode results */
 868       if(encRetVal.encoded == ENCODE_FAIL)
 869       {
 870          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 871                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 872          break;
 873       }
 874       else
 875       {
 876          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 877          for(idx=0; idx< encBufSize; idx++)
 878          {
 879             DU_LOG("%x",encBuf[idx]);
 880          }
 881       }
 882
 883       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 884       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 885       {
 886          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 887          break;
 888       }
 889
 890       ret = ROK;
 891       break;
 892    }while(true);
 893
 894    FreeF1ResetReq(f1apMsg);
 895    return ret;
 896 }
 897
 898 /*******************************************************************
 899  *
 900  * @brief Fills Radio Bearer Config
 901  *
 902  * @details
 903  *
 904  *    Function : fillSrbCfg
 905  *
 906  *    Functionality: Fills Radio Bearer Config
 907  *
 908  * @params[in] SRB_ToAddModList *
 909  *
 910  * @return ROK     - success
 911  *         RFAILED - failure
 912  *
 913  * ****************************************************************/
 914 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 915 {
 916    uint8_t elementCnt = 0;
 917    uint8_t idx, ieId, srbIdx = 0;
 918
 919    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 920    {
 921       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 922          elementCnt++;
 923    }
 924
 925    if(bearerCfg != NULLP)
 926    {
 927       bearerCfg->list.count = elementCnt;
 928       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 929       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 930       if(bearerCfg->list.array != NULLP)
 931       {
 932          for(idx = 0; idx < elementCnt; idx++)
 933          {
 934             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 935             if(bearerCfg->list.array[idx] == NULLP)
 936             {
 937                for(ieId = 0; ieId < idx; ieId++)
 938                {
 939                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 940                }
 941                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 942                return RFAILED;
 943             }
 944          }
 945       }
 946       else
 947       {
 948          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 949          return RFAILED;
 950       }
 951
 952       idx = 0;
 953       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 954       {
 955          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 956             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 957       }
 958    }
 959    return ROK;
 960 }
 961
 962 /*******************************************************************
 963  *
 964  * @brief Fills Master CellGroup Info
 965  *
 966  * @details
 967  *
 968  *    Function : fillMasterCellGroup
 969  *
 970  *    Functionality: Fills Master Cell Group IE
 971  *
 972  * @params[in] RRCSetup_IEs_t *
 973  *
 974  * @return ROK     - success
 975  *         RFAILED - failure
 976  *
 977  * ****************************************************************/
 978
 979 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 980 {
 981    uint8_t ret = ROK;
 982    masterCellGroup->buf = NULLP;
 983    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 984    {
 985       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 986       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 987       if(masterCellGroup->buf != NULLP)
 988       {
 989          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
 990       }
 991       else
 992       {
 993          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
 994          ret = RFAILED;
 995       }
 996    }
 997    else
 998    {
 999       ret =  RFAILED;
1000    }
1001    return ret;
1002 }
1003
1004 /*******************************************************************
1005  *
1006  * @brief Fills RRC setup IE
1007  *
1008  * @details
1009  *
1010  *    Function : fillRRCSetupIE
1011  *
1012  *    Functionality: Fills RRC Setup IE
1013  *
1014  * @params[in] RRCSetup_IEs_t *
1015  *
1016  * @return ROK     - success
1017  *         RFAILED - failure
1018  *
1019  * ****************************************************************/
1020
1021 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1022 {
1023    uint8_t ret = ROK, srbIdx = 0;
1024    if(rrcSetupIE)
1025    {
1026       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1027       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1028       {
1029          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1030       }
1031       if(ret == ROK)
1032       {
1033          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1034       }
1035       else
1036       {
1037          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1038          ret = RFAILED;
1039       }
1040
1041       /* If SRB configuration are filled successfully in RRC Setup, mark these
1042        * configurartion as sent to UE */
1043       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1044       {
1045          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1046             ueCb->srbList[srbIdx].cfgSentToUe = true;
1047       }
1048    }
1049    return ret;
1050 }
1051 /*******************************************************************
1052  *
1053  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1054  *
1055  * @details
1056  *
1057  *    Function : fillDlCcchRrcMsg
1058  *
1059  *    Functionality: Fills DL DCCCH Message required for
1060  *                   DLRRCMessageTransfer
1061  *
1062  * @params[in] RRCContainer_t *rrcContainer
1063  *
1064  * @return ROK     - success
1065  *         RFAILED - failure
1066  *
1067  * ****************************************************************/
1068
1069 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1070 {
1071    uint8_t ret = ROK;
1072    uint16_t idx2;
1073    DL_CCCH_Message_t dl_CCCH_Msg;
1074    asn_enc_rval_t    encRetVal;
1075
1076    if(rrcContainer != NULLP)
1077    {
1078       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1079
1080       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1081       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1082       {
1083          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1084          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1085          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1086          {
1087             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1088             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1089                RRCSetup__criticalExtensions_PR_rrcSetup;
1090
1091             /* Fill RRC Setup IE */
1092             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1093                sizeof(RRCSetup_IEs_t));
1094             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1095             {
1096                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1097
1098                if(ret == ROK)
1099                {
1100                   /* encode DL-CCCH message into RRC Container */
1101                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1102                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1103                   encBufSize = 0;
1104                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1105                   /* Encode results */
1106                   if(encRetVal.encoded == ENCODE_FAIL)
1107                   {
1108                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1109                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1110                      return RFAILED;
1111                   }
1112                   else
1113                   {
1114                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1115                      for(int i = 0; i< encBufSize; i++)
1116                      {
1117                         DU_LOG("%x",encBuf[i]);
1118                      }
1119                      rrcContainer->size = encBufSize;
1120                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1121                      if(rrcContainer->buf != NULLP)
1122                      {
1123                         memset(rrcContainer->buf, 0, encBufSize);
1124                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1125                         {
1126                            rrcContainer->buf[idx2] =    encBuf[idx2];
1127                         }
1128                      }
1129                   }
1130                }
1131                else
1132                {
1133                   ret = RFAILED;
1134                }
1135             }
1136             else
1137             {
1138                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1139                ret = RFAILED;
1140             }
1141          }
1142          else
1143          {
1144             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1145             ret = RFAILED;
1146          }
1147       }
1148       else
1149       {
1150          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1151          ret = RFAILED;
1152       }
1153    }
1154    else
1155    {
1156       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1157       ret = RFAILED;
1158    }
1159 }
1160
1161 /*******************************************************************
1162  *
1163  * @brief Fills QOS flow configuration
1164  *
1165  * @details
1166  *
1167  *    Function : fillQosFlowsToAdd
1168  *
1169  *    Functionality: Fills QOS flow configuration
1170  *
1171  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1172  *
1173  * @return ROK     - success
1174  *         RFAILED - failure
1175  *
1176  * ****************************************************************/
1177 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1178 {
1179    uint8_t idx, ied, elementCnt;
1180
1181    elementCnt = 1;
1182    qosFlow->list.count = elementCnt;
1183    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1184    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1185    if(qosFlow->list.array != NULLP)
1186    {
1187       for(idx = 0; idx < elementCnt; idx++)
1188       {
1189          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1190          if(qosFlow->list.array[idx] == NULLP)
1191          {
1192             for(ied = 0; ied < idx; ied++)
1193             {
1194                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1195             }
1196             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1197             return RFAILED;
1198          }
1199       }
1200    }
1201    idx = 0;
1202    *qosFlow->list.array[idx] = 9;
1203    return ROK;
1204 }
1205
1206 /*******************************************************************
1207  *
1208  * @brief Fills CN Assoc for Drb to Add/Mod List
1209  *
1210  * @details
1211  *
1212  *    Function : fillCnAssoc
1213  *
1214  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1215  *
1216  * @params[in] struct DRB_ToAddMod__cnAssociation *
1217  *
1218  * @return ROK     - success
1219  *         RFAILED - failure
1220  *
1221  * ****************************************************************/
1222
1223 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1224 {
1225    uint8_t ret = ROK;
1226
1227    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1228    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1229    {
1230       cnAssoc->choice.eps_BearerIdentity = 5;
1231    }
1232    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1233    {
1234       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1235       if(cnAssoc->choice.sdap_Config)
1236       {
1237          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1238          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1239          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1240          cnAssoc->choice.sdap_Config->defaultDRB = true;
1241          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1242          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1243          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1244                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1245          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1246          {
1247             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1248          }
1249          else
1250          {
1251             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1252             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1253             ret = RFAILED;
1254          }
1255       }
1256       else
1257       {
1258          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1259          ret = RFAILED;
1260       }
1261    }
1262    return ret;
1263 }
1264
1265 /*******************************************************************
1266  *
1267  * @brief Fills Radio Bearer Config for Drb
1268  *
1269  * @details
1270  *
1271  *    Function : fillDrbCfg
1272  *
1273  *    Functionality: Fills Radio Bearer Config for Drb
1274  *
1275  * @params[in] drbId, DRB_ToAddModList *
1276  *
1277  * @return ROK     - success
1278  *         RFAILED - failure
1279  *
1280  * ****************************************************************/
1281 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1282 {
1283    uint8_t idx, ied, ret, elementCnt;
1284
1285    ret = ROK;
1286    if(drbCfg != NULLP)
1287    {
1288       elementCnt = 1;
1289       drbCfg->list.count = elementCnt;
1290       drbCfg->list.size =\
1291                          elementCnt * sizeof(DRB_ToAddMod_t *);
1292       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1293       if(drbCfg->list.array != NULLP)
1294       {
1295          for(idx = 0; idx < elementCnt; idx++)
1296          {
1297             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1298             if(drbCfg->list.array[idx] == NULLP)
1299             {
1300                for(ied = 0; ied < idx; ied++)
1301                {
1302                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1303                }
1304                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1305                return RFAILED;
1306             }
1307          }
1308       }
1309       else
1310       {
1311          return RFAILED;
1312       }
1313       idx = 0;
1314       /* CN ASSOCIATION */
1315       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1316       if(drbCfg->list.array[idx]->cnAssociation)
1317       {
1318          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1319       }
1320       /* DRB */
1321       drbCfg->list.array[idx]->drb_Identity = drbId;
1322    }
1323    return ret;
1324 }
1325
1326 /*******************************************************************
1327  *
1328  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1329  *
1330  * @details
1331  *
1332  *    Function : fillRrcReconfigIE
1333  *
1334  *    Functionality: Fills RRC Reconfig Message required for
1335  *                   DLRRCMessageTransfer
1336  *
1337  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1338  *
1339  * @return ROK     - success
1340  *         RFAILED - failure
1341  *
1342  * ****************************************************************/
1343
1344 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1345 {
1346    uint8_t ret = ROK;
1347    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1348    if(rrcReconfigMsg->radioBearerConfig)
1349    {
1350       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1351       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1352       {
1353          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1354
1355       }
1356       if(ret == ROK)
1357       {
1358          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1359          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1360          {
1361             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1362             if(ret == RFAILED)
1363             {
1364                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1365                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1366                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1367             }
1368          }
1369       }
1370       else
1371       {
1372          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1373          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1374       }
1375    }
1376
1377    return ret;
1378 }
1379 /*******************************************************************
1380  *
1381  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1382  *
1383  * @details
1384  *
1385  *    Function : fillDlDcchRrcMsg
1386  *
1387  *    Functionality: Fills DL DCCH Message required for
1388  *                   DLRRCMessageTransfer
1389  *
1390  * @params[in] RRCContainer_t *rrcContainer
1391  *
1392  * @return ROK     - success
1393  *         RFAILED - failure
1394  *
1395  * ****************************************************************/
1396
1397 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1398 {
1399    uint8_t ret = ROK;
1400    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1401    DL_DCCH_Message_t dl_DCCH_Msg;
1402    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1403    asn_enc_rval_t        encRetVal;
1404
1405    if(rrcContainer != NULLP)
1406    {
1407       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1408
1409       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1410       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1411       {
1412          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1413          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1414          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1415          {
1416             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1417             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1418             if(ret == ROK)
1419             {
1420                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1421                 * configurartion as sent to UE */
1422                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1423                {
1424                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1425                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1426                }
1427                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1428                {
1429                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1430                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1431                }
1432
1433                /* encode DL-DCCH message into RRC Container */
1434                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1435                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1436                encBufSize = 0;
1437                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1438                /* Encode results */
1439                if(encRetVal.encoded == ENCODE_FAIL)
1440                {
1441                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1442                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1443                   return RFAILED;
1444                }
1445                else
1446                {
1447                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1448                   for(int i = 0; i< encBufSize; i++)
1449                   {
1450                      DU_LOG("%x",encBuf[i]);
1451                   }
1452                   rrcContainer->size = encBufSize;
1453                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1454                   if(rrcContainer->buf != NULLP)
1455                   {
1456                      memset(rrcContainer->buf, 0, encBufSize);
1457                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1458                      {
1459                         rrcContainer->buf[idx2] =       encBuf[idx2];
1460                      }
1461                   }
1462                }
1463             }
1464          }
1465          else
1466          {
1467             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1468             ret = RFAILED;
1469          }
1470       }
1471       else
1472       {
1473          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1474          ret = RFAILED;
1475       }
1476    }
1477    else
1478    {
1479       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1480       ret = RFAILED;
1481    }
1482    return ret;
1483 }
1484
1485 /*******************************************************************
1486  *
1487  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1488  *
1489  * @details
1490  *
1491  *    Function : BuildDLRRCContainer
1492  *
1493  *    Functionality: Builds RRC Container IE required for
1494  *                   DLRRCMessageTransfer
1495  *
1496  * @params[in]
1497  *
1498  * @return ROK     - success
1499  *         RFAILED - failure
1500  *
1501  * ****************************************************************/
1502
1503 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1504 {
1505    uint8_t ret, bufLen;
1506
1507    ret =ROK;
1508    if(rrcMsgType == RRC_SETUP)
1509    {
1510       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1511       if(ret == RFAILED)
1512          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1513    }
1514    else if(rrcMsgType == RRC_SETUP_COMPLETE)
1515    {
1516       DU_LOG("\nINFO --> F1AP : Sending Security mode command");
1517       char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1518       bufLen =9;
1519       rrcContainer->size = bufLen;
1520       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1521       if(rrcContainer->buf != NULLP)
1522       {
1523          memset(rrcContainer->buf, 0, bufLen);
1524          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1525       }
1526       else
1527       {
1528          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1529          ret = RFAILED;
1530       }
1531    }
1532    else if(rrcMsgType == SECURITY_MODE_COMPLETE)
1533    {
1534       /*Hardcoded RRC Container from reference logs*/
1535       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1536       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1537       bufLen =14;
1538       rrcContainer->size = bufLen;
1539       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1540       if(rrcContainer->buf != NULLP)
1541       {
1542          memset(rrcContainer->buf, 0, bufLen);
1543          memcpy(rrcContainer->buf, buf, bufLen);
1544       }
1545       else
1546       {
1547          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1548          ret = RFAILED;
1549       }
1550    }
1551    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1552    {
1553       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1554       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1555       if(ret == RFAILED)
1556          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1557    }
1558
1559    return ret;
1560 }
1561
1562 /*******************************************************************
1563  *
1564  * @brief Frees the DLRRCMessageTransfer
1565  *
1566  * @details
1567  *
1568  *    Function : freeDlRrcMessageTransfer
1569  *
1570  *    Functionality: Frees the DLRRCMessageTransfer
1571  *
1572  * @params[in]
1573  *
1574  * @return ROK     - success
1575  *         RFAILED - failure
1576  *
1577  * ****************************************************************/
1578 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1579 {
1580    uint8_t idx=0;
1581    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1582
1583    if(f1apMsg)
1584    {
1585       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1586       if(dlRRCMsg->protocolIEs.list.array)
1587       {
1588          idx = 3;
1589          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1590             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1591          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1592          {
1593             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1594          }
1595          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1596       }
1597       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1598    }
1599 }
1600
1601 /*******************************************************************
1602  *
1603  * @brief Builds and sends the DLRRCMessageTransfer
1604  *
1605  * @details
1606  *
1607  *    Function : BuildAndSendDLRRCMessageTransfer
1608  *
1609  *    Functionality: Constructs the DL RRC Message Transfer and sends
1610  *                   it to the CU through SCTP.
1611  *
1612  * @params[in]
1613  *
1614  * @return ROK     - success
1615  *         RFAILED - failure
1616  *
1617  * ****************************************************************/
1618 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1619 {
1620    uint8_t   elementCnt = 0;
1621    uint8_t  ieId;
1622    uint8_t  idx;
1623    F1AP_PDU_t  *f1apMsg = NULLP;
1624    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1625    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1626
1627    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1628
1629    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1630    if(f1apMsg == NULLP)
1631    {
1632       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1633       return RFAILED;
1634    }
1635
1636    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1637    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1638    if(f1apMsg->choice.initiatingMessage == NULLP)
1639    {
1640       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1641       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1642       return RFAILED;
1643    }
1644
1645    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1646    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1647    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1648    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1649
1650    elementCnt = 4;
1651    dlRRCMsg->protocolIEs.list.count = elementCnt;
1652    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1653
1654    /* Initialize the F1Setup members */
1655    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1656    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1657    {
1658       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1659       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1660       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1661       return RFAILED;
1662    }
1663
1664    for(idx=0; idx<elementCnt; idx++)
1665    {
1666       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1667       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1668       {
1669          for(ieId=0; ieId<idx; ieId++)
1670          {
1671             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1672          }
1673          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1674          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1675          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1676          return RFAILED;
1677       }
1678    }
1679
1680    /* GNB CU UE F1AP ID */
1681    idx = 0;
1682    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1683    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1684    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1685    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1686
1687    /* GNB DU UE F1AP ID */
1688    idx++;
1689    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1690    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1691    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1692    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1693
1694    /* SRBID */
1695    idx++;
1696    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1697    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1698    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1699    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1700
1701    /* RRCContainer */
1702    idx++;
1703    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1704    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1705    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1706    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1707
1708    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1709
1710    /* Encode the F1SetupRequest type as APER */
1711    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1712    encBufSize = 0;
1713    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1714          encBuf);
1715    /* Encode results */
1716    if(encRetVal.encoded == ENCODE_FAIL)
1717    {
1718       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1719             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1720       return RFAILED;
1721    }
1722    else
1723    {
1724       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1725       for(int i=0; i< encBufSize; i++)
1726       {
1727          DU_LOG("%x",encBuf[i]);
1728       }
1729    }
1730
1731    /* Sending  msg  */
1732    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1733    {
1734       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1735       return RFAILED;
1736    }
1737    freeDlRrcMessageTransfer(f1apMsg);
1738    return ROK;
1739 }/* End of BuildAndSendDLRRCMessageTransfer */
1740
1741 /*******************************************************************
1742  *
1743  * @brief Function to set the Dl RRC Msg Type
1744  *
1745  * @details
1746  *
1747  *    Function : setDlRRCMsgType
1748  *
1749  *    Functionality: Constructs the UE Setup Response and sends
1750  *                   it to the DU through SCTP.
1751  *
1752  * @params[in]
1753  *
1754  * @return ROK     - success
1755  *         RFAILED - failure
1756  *
1757  * ****************************************************************/
1758
1759 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1760 {
1761    uint8_t rrcMsgType = 0;
1762    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1763    {
1764       case RRC_SETUP:
1765          rrcMsgType = RRC_SETUP;
1766          break;
1767       case RRC_SETUP_COMPLETE:
1768          rrcMsgType = RRC_SETUP_COMPLETE;
1769          break;
1770       case SECURITY_MODE_COMPLETE:
1771          rrcMsgType = SECURITY_MODE_COMPLETE;
1772          break;
1773       case REGISTRATION_COMPLETE:
1774          rrcMsgType = REGISTRATION_COMPLETE;
1775          break;
1776       case UE_CONTEXT_SETUP_RSP:
1777          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1778          break;
1779       case RRC_RECONFIG_COMPLETE:
1780          rrcMsgType = RRC_RECONFIG_COMPLETE;
1781          break;
1782       default:
1783          break;
1784    }
1785    return rrcMsgType;
1786 }
1787
1788 /*******************************************************************
1789  *
1790  * @brief Extract configuration from CellGroupConfig
1791  *
1792  * @details
1793  *
1794  *    Function : extractCellGroupConfig
1795  *
1796  *    Functionality: Extract configuration from CellGroupConfig
1797  *        and store in local database
1798  *
1799  * @params[in] UE control block
1800  *             Cell Group Config
1801  *
1802  * @return ROK     - success
1803  *         RFAILED - failure
1804  *
1805  * ****************************************************************/
1806 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1807 {
1808    uint8_t rbIdx, srbIdx, drbIdx;
1809    bool    srbFound, drbFound;
1810    SrbInfo *srbCfgDb = NULLP;
1811    DrbInfo *drbCfgDb = NULLP;
1812    RlcLcCfg *rlcLcCfgDb = NULLP;
1813    MacLcCfg *macLcCfgDb = NULLP;
1814    RLC_BearerConfig_t *rlcCfg = NULLP;
1815    RLC_Config_t *rlcLcCfg = NULLP;
1816    LogicalChannelConfig_t *macLcCfg = NULLP;
1817
1818    if(ueCb == NULLP)
1819    {
1820       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
1821       return RFAILED;
1822    }
1823
1824    if(cellGrpCfg == NULLP)
1825    {
1826       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
1827       return RFAILED;
1828    }
1829
1830    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
1831    {
1832       srbFound = false;
1833       drbFound = false;
1834
1835       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
1836
1837       /* Update SRB configuration in local DB */
1838       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
1839       {
1840          /* Search if SRB entry is already present in DB */
1841          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
1842          {
1843             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
1844             {
1845               srbCfgDb = &ueCb->srbList[srbIdx];
1846               srbFound = true;
1847               break;
1848             }
1849          }
1850
1851          /* If not, add SRB to UE CB's SRB list */
1852          if(!srbFound)
1853          {
1854             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
1855             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
1856             ueCb->numSrb++;
1857          }
1858
1859          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1860          srbCfgDb->cfgSentToUe = false;
1861          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
1862          macLcCfgDb = &srbCfgDb->macLcCfg;
1863       }
1864
1865       /* Update DRB configuration in local DB */
1866       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
1867       {
1868          /* Search if DRB entry is already present in DB */
1869          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
1870          {
1871             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
1872             {
1873               drbCfgDb = &ueCb->drbList[drbIdx];
1874               drbFound = true;
1875               break;
1876             }
1877          }
1878
1879          /* If not, add DRB to UE CB's SRB list */
1880          if(!drbFound)
1881          {
1882             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
1883             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
1884             ueCb->numDrb++;
1885          }
1886
1887          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1888          drbCfgDb->cfgSentToUe = false;
1889          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
1890          macLcCfgDb = &drbCfgDb->macLcCfg;
1891       }
1892
1893
1894       /* Update RLC configuration for this RB */
1895       rlcLcCfg = rlcCfg->rlc_Config;
1896       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
1897       switch(rlcLcCfgDb->rlcMode)
1898       {
1899          case RLC_Config_PR_am:
1900             {
1901                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
1902                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
1903                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
1904                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
1905                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
1906
1907                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
1908                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
1909                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
1910                break;
1911             }
1912
1913          case RLC_Config_PR_um_Bi_Directional:
1914             {
1915                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
1916
1917                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
1918                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
1919                break;
1920             }
1921       }
1922
1923       /* Update MAC configuration for this LC */
1924       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
1925       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
1926       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
1927       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
1928       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
1929       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
1930    }
1931    return ROK;
1932 }
1933
1934 /*******************************************************************
1935  *
1936  * @brief Function to decode DU to CU RRC container
1937  *
1938  * @details
1939  *
1940  *    Function : extractDuToCuRrcCont
1941  *
1942  *    Functionality: Function to decode DU to CU RRC container
1943  *
1944  * @params[in] UE Cb
1945  *             RRC conatiner octect string to be decoded
1946  *
1947  * @return ROK     - success
1948  *         RFAILED - failure
1949  *
1950  * ****************************************************************/
1951 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
1952 {
1953    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
1954    asn_dec_rval_t rval; /* Decoder return value */
1955
1956    /* Copy the received container to UeCb */
1957    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
1958
1959    /* Decoding DU to CU RRC container octet string to cell group config */
1960    cellGrpCfgMsg = &cellGrpCfg;
1961    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
1962
1963    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
1964
1965    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1966    {
1967       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
1968       return RFAILED;
1969    }
1970    printf("\n");
1971    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
1972
1973    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
1974    {
1975       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
1976       return RFAILED;
1977    }
1978
1979    return ROK;
1980 }
1981
1982 /*******************************************************************
1983  *
1984  * @brief Function to build Initial UL RRC Message
1985  *
1986  * @details
1987  *
1988  *    Function : procInitULRRCMsg
1989  *
1990  *    Functionality: Function to build Initial UL RRC Message
1991  *
1992  * @params[in]
1993  *
1994  * @return ROK     - success
1995  *         RFAILED - failure
1996  *
1997  * ****************************************************************/
1998
1999 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2000 {
2001    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2002    uint8_t ret =ROK;
2003    uint16_t cellIdx=0, nrCellId = 0;
2004    uint32_t crnti;
2005    DuDb     *duDb;
2006    CuCellCb *cellCb;
2007    CuUeCb   *ueCb;
2008    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2009
2010    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2011
2012    SEARCH_DU_DB(duIdx, duId, duDb);
2013    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2014
2015    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2016    {
2017       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2018       {
2019          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2020             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2021             break;
2022
2023          case ProtocolIE_ID_id_NRCGI:
2024             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2025             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2026             if(cellCb == NULLP)
2027                return RFAILED;
2028             break;
2029
2030          case ProtocolIE_ID_id_C_RNTI:
2031             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2032             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2033             {
2034                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2035                memset(ueCb, 0, sizeof(CuUeCb));
2036                ueCb->cellCb = cellCb;
2037                ueCb->crnti = crnti;
2038                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2039                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2040                ueCb->state = UE_ATTACH_IN_PROGRESS;
2041                (duDb->numUe)++;
2042
2043                cellCb->ueCb[cellCb->numUe] = ueCb;
2044                cellCb->numUe++;
2045             }
2046             break;
2047
2048          case ProtocolIE_ID_id_RRCContainer:
2049             break;
2050
2051          case ProtocolIE_ID_id_DUtoCURRCContainer:
2052             {
2053                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2054                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2055                {
2056                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2057                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2058                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2059                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2060                   {
2061                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2062                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2063                         ueCb->f1apMsgDb.duToCuContainer.size);
2064                   }
2065                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2066                   {
2067                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2068                      ret = RFAILED;
2069                   }
2070                }
2071                else
2072                {
2073                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2074                   ret = RFAILED;
2075                }
2076                break;
2077             }
2078
2079          default:
2080             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2081             break;
2082       }
2083       if(ret == RFAILED)
2084          break;
2085    }
2086
2087    if(ret == ROK)
2088    {
2089       ueCb->f1apMsgDb.dlRrcMsgCount++;
2090       rrcMsgType = setDlRRCMsgType(ueCb);
2091       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2092    }
2093    return ret;
2094 }
2095
2096 /*******************************************************************
2097  *
2098  * @brief Builds Nrcgi
2099  *
2100  * @details
2101  *
2102  *    Function : BuildNrcgi
2103  *
2104  *    Functionality: Building the PLMN ID and NR Cell id
2105  *
2106  * @params[in] NRCGI_t *nrcgi
2107  * @return ROK     - success
2108  *         RFAILED - failure
2109  *
2110  * ****************************************************************/
2111 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2112 {
2113    uint8_t ret;
2114    uint8_t unused_bits = 4;
2115    uint8_t byteSize = 5;
2116
2117    /* Allocate Buffer Memory */
2118    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2119    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2120    if(nrcgi->pLMN_Identity.buf == NULLP)
2121    {
2122       return RFAILED;
2123    }
2124    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2125
2126    if(ret != ROK)
2127    {
2128       return RFAILED;
2129    }
2130    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2131    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2132    if(nrcgi->nRCellIdentity.buf == NULLP)
2133    {
2134       return RFAILED;
2135    }
2136    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2137
2138    return ROK;
2139 }
2140 /*******************************************************************
2141  *
2142  * @brief Builds Special cell list for UE Setup Request
2143  *
2144  * @details
2145  *
2146  *    Function : BuildSplCellList
2147  *
2148  *    Functionality: Constructs the Special Cell list for UESetReq
2149  *
2150  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2151  *
2152  * @return ROK     - success
2153  *         RFAILED - failure
2154  *
2155  * ****************************************************************/
2156 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2157 {
2158    uint8_t  cellCnt;
2159    uint8_t  idx;
2160    uint8_t  ret;
2161    cellCnt = 1;
2162    spCellLst->list.count = cellCnt;
2163    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2164    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2165    if(spCellLst->list.array == NULLP)
2166    {
2167       return RFAILED;
2168    }
2169    for(idx=0; idx<cellCnt; idx++)
2170    {
2171       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2172       if(spCellLst->list.array[idx] == NULLP)
2173       {
2174          return RFAILED;
2175       }
2176    }
2177    idx = 0;
2178    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2179    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2180    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2181
2182    /* Special Cell ID -NRCGI */
2183    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2184    if(ret != ROK)
2185    {
2186       return RFAILED;
2187    }
2188    /*Special Cell Index*/
2189    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2190    return ROK;
2191 }/* End of BuildSplCellList*/
2192
2193 /*******************************************************************
2194  *
2195  * @brief Builds SRBS to be setup
2196  *
2197  * @details
2198  *
2199  *    Function : BuildSRBSetup
2200  *
2201  *    Functionality: Constructs the SRB's for UESetReq
2202  *
2203  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2204  *
2205  * @return ROK     - success
2206  *         RFAILED - failure
2207  *
2208  * ****************************************************************/
2209 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2210 {
2211    uint8_t idx;
2212    uint8_t srbCnt;
2213
2214    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2215       srbCnt = ueCb->numSrb;
2216    else
2217       srbCnt = 1;
2218    srbSet->list.count = srbCnt;
2219    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2220    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2221    if(srbSet->list.array == NULLP)
2222    {
2223       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2224       return RFAILED;
2225    }
2226
2227    for(idx=0; idx<srbCnt; idx++)
2228    {
2229       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2230       if(srbSet->list.array[idx] == NULLP)
2231       {
2232          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2233          return RFAILED;
2234       }
2235    }
2236
2237    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2238    {
2239       idx = 0;
2240       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2241       srbSet->list.array[idx]->criticality = Criticality_ignore;
2242       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2243       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2244       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2245       ueCb->numSrb++;
2246    }
2247    else
2248    {
2249       for(idx=0; idx<srbCnt; idx++)
2250       {
2251          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2252          srbSet->list.array[idx]->criticality = Criticality_ignore;
2253          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2254          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2255       }
2256    }
2257    return ROK;
2258 }/* End of BuildSRBSetup*/
2259
2260 /*******************************************************************
2261  *
2262  * @brief Builds QOS Info for DRB Setum Item
2263  *
2264  * @details
2265  *
2266  *    Function : BuildQOSInfo
2267  *
2268  *    Functionality: Constructs the QOS Info for DRB Setup Item
2269  *
2270  * @params[in] QoSInformation_t *qosinfo
2271  *             int16_t pduSessionID
2272  *
2273  * @return ROK     - success
2274  *         RFAILED - failure
2275  *
2276  * ****************************************************************/
2277 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2278 {
2279    uint8_t elementCnt = 0, qosCntIdx = 0;
2280    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2281
2282    /* NonDynamic5QIDescriptor */
2283    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2284    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2285    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2286    {
2287       return RFAILED;
2288    }
2289
2290    if(hoInProgress)
2291       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2292    else
2293    {
2294       /*FiveQI*/
2295       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2296          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2297       else
2298          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2299
2300       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2301    }
2302
2303    if(!hoInProgress)
2304    {
2305       /*AveragingWindow*/
2306       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2307       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2308       {
2309          return RFAILED;
2310       }
2311       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2312       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2313
2314       /*MaxDataBurstVolume*/
2315       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2316       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2317       {
2318          return RFAILED;
2319       }
2320       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2321       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2322    }
2323
2324    /*nRGRAN Allocation Retention Priority*/
2325    if(hoInProgress)
2326    {
2327       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2328       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2329       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2330    }
2331    else
2332    {
2333       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2334       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2335       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2336
2337       qosInfo->priorityLevel = PriorityLevel_lowest;
2338       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2339       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2340    }
2341
2342    /* PDU session ID */
2343    if(!hoInProgress)
2344    {
2345       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2346       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2347       {
2348          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2349          return ROK;
2350       }
2351
2352       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2353       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2354
2355       if(qosIeExt)
2356       {
2357          elementCnt = NUM_QOS_EXT;
2358          qosIeExt->list.count = elementCnt;
2359          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2360
2361          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2362          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2363
2364          if(qosIeExt->list.array == NULLP)
2365          {
2366             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2367             return  RFAILED;
2368          }
2369
2370          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2371          {
2372             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2373             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2374             {
2375                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2376                return  RFAILED;
2377             }
2378             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2379             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2380             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2381             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2382             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2383                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2384             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2385             qosInfo->pduSessionId = pduSessionID;
2386          }
2387       }
2388       else
2389       {
2390          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2391          return RFAILED;
2392       }
2393    }
2394    return ROK;
2395 }/*End of BuildQOSInfo*/
2396
2397 /*******************************************************************
2398  *
2399  * @brief Builds SNSSAI
2400  *
2401  * @details
2402  *
2403  *    Function : BuildSNSSAI
2404  *
2405  *    Functionality: Constructs the SNSSAI For DRB list
2406  *
2407  * @params[in] SNSSAI_t *snssai
2408  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2409  *
2410  * @return ROK     - success
2411  *         RFAILED - failure
2412  *
2413  * ****************************************************************/
2414 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2415 {
2416    /*SNSSAI*/
2417    /*ssT*/
2418    snssai->sST.size = sizeof(uint8_t);
2419    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2420    if(snssai->sST.buf == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    if(!hoInProgress)
2425       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2426    else
2427       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2428
2429    /*sD*/
2430    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2431    if(snssai->sD == NULLP)
2432    {
2433       return RFAILED;
2434    }
2435    snssai->sD->size = 3 * sizeof(uint8_t);
2436    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2437    if(snssai->sD->buf == NULLP)
2438    {
2439       return RFAILED;
2440    }
2441    if(!hoInProgress)
2442       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2443    else
2444       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2445
2446    if(!hoInProgress)
2447       drbInfo->snssai = snssaiToCopy;
2448    return ROK;
2449 }/*End of BuildSNSSAI*/
2450
2451 /*******************************************************************
2452  *
2453  * @brief Builds the flow map.
2454  *
2455  * @details
2456  *
2457  *    Function : BuildFlowsMap
2458  *
2459  *    Functionality: Constructs the flowmap For DRB list
2460  *
2461  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2462  *
2463  * @return ROK     - success
2464  *         RFAILED - failure
2465  *
2466  * ****************************************************************/
2467 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2468 {
2469    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2470    FlowsMapped *qosFlow;
2471
2472    if(!hoInProgress)
2473       flowCnt = 1;
2474    else
2475       flowCnt = drbInfo->numFlowMap;
2476    flowMap->list.count = flowCnt;
2477    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2478    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2479    if(flowMap->list.array == NULLP)
2480    {
2481       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2482       return RFAILED;
2483    }
2484    for(idx=0; idx<flowCnt; idx++)
2485    {
2486       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2487       if(flowMap->list.array[idx] == NULLP)
2488       {
2489          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2490          return RFAILED;
2491       }
2492
2493       if(!hoInProgress)
2494       {
2495          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2496          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2497          {
2498             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2499             {
2500                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2501                {
2502                   qosFlow = &drbInfo->flowMapList[flowIdx];
2503                   break;
2504                }
2505             }
2506          }
2507          else
2508          {
2509             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2510             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2511          }
2512       }
2513       else
2514       {
2515          qosFlow = &drbInfo->flowMapList[idx];
2516          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2517       }
2518
2519       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2520             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2521       if(ret != ROK)
2522       {
2523          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2524          return RFAILED;
2525       }
2526
2527       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2528          drbInfo->numFlowMap++;
2529    }
2530    return ROK;
2531 }/*End of BuildFlowsMap*/
2532
2533 /*******************************************************************
2534  *
2535  * @brief Builds the Uplink Tunnel Info
2536  *
2537  * @details
2538  *
2539  *    Function : BuildULTnlInfo
2540  *
2541  *    Functionality: Constructs the UL TnlInfo For DRB list
2542  *
2543  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2544  *
2545  * @return ROK     - success
2546  *         RFAILED - failure
2547  *
2548  * ****************************************************************/
2549 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2550 {
2551    uint8_t idx;
2552    uint8_t ulCnt;
2553
2554    ulCnt = 1;
2555    ulInfo->list.count = ulCnt;
2556    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2557    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2558    if(ulInfo->list.array == NULLP)
2559    {
2560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2561       return RFAILED;
2562    }
2563    for(idx=0; idx<ulCnt; idx++)
2564    {
2565       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2566       if(ulInfo->list.array[idx] == NULLP)
2567       {
2568          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2569               return RFAILED;
2570       }
2571    }
2572    idx = 0;
2573    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2574    /*GTP TUNNEL*/
2575    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2576    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2577    {
2578       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2579       return RFAILED;
2580    }
2581    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2582    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2583       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2584    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2585    {
2586       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2587       return RFAILED;
2588    }
2589
2590    if(!hoInProgress)
2591    {
2592       /* NOTE: Below IP address must be changed if running on different IP configuration */
2593       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2594       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2595       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2596       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2597       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2598
2599       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2600       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2601       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2602       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2603    }
2604    else
2605    {
2606       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2607       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2608       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2609       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2610       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2611    }
2612
2613    /*GTP TEID*/
2614    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2615    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2616       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2617    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2618    {
2619       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2620       return RFAILED;
2621    }
2622
2623    if(!hoInProgress)
2624    {
2625       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2626       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2627       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2628       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2629
2630       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2631       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2632       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2633       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2634    }
2635    else
2636    {
2637       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2638       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2639       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2640       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2641    }
2642    return ROK;
2643 }/*End of BuildULTnlInfo*/
2644
2645 /*******************************************************************
2646  *
2647  * @brief Builds DRBS to be setup
2648  *
2649  * @details
2650  *
2651  *    Function : BuildDRBSetup
2652  *
2653  *    Functionality: Constructs the DRB's for UESetReq
2654  *
2655  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2656  *
2657  * @return ROK     - success
2658  *         RFAILED - failure
2659  *
2660  * ****************************************************************/
2661 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2662 {
2663    uint8_t idx = 0, extIeIdx = 0;
2664    uint8_t elementCnt = 0, drbCnt = 0;
2665    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2666    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2667    DRBs_ToBeSetup_Item_t *drbSetItem;
2668    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2669    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2670
2671    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2672       drbCnt = ueCb->numDrb;
2673    else
2674       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2675    drbSet->list.count = drbCnt;
2676
2677    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2678    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2679    if(drbSet->list.array == NULLP)
2680    {
2681       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2682       return RFAILED;
2683    }
2684
2685    for(idx=0; idx<drbCnt; idx++)
2686    {
2687       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2688       if(drbSet->list.array[idx] == NULLP)
2689       {
2690          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2691          return RFAILED;
2692       }
2693
2694       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2695       drbSet->list.array[idx]->criticality = Criticality_ignore;
2696       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2697       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2698       /*dRBID*/
2699       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2700       {
2701          drbSetItem->dRBID = idx + 1;
2702          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2703       }
2704       else
2705          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2706
2707       /*qoSInformation*/
2708       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2709       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2710       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2711       {
2712          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2713          return RFAILED;
2714       }
2715       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2716       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2717       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2718       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2719          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2720                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2721       else
2722          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2723                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2724       if(BuildQOSInforet != ROK)
2725       {
2726          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2727          return RFAILED;
2728       }
2729
2730       /*SNSSAI*/
2731       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2732          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2733                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
2734       else
2735          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2736                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], TRUE);
2737       if(BuildSNSSAIret != ROK)
2738       {
2739          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2740          return RFAILED;
2741       }
2742
2743       /*Flows mapped to DRB List*/
2744       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2745          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2746                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2747       else
2748          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2749                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2750       if(BuildFlowsMapret != ROK)
2751       {
2752          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2753          return RFAILED;
2754       }
2755
2756       /*ULUPTNLInformation To Be Setup List*/
2757       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2758          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2759                FALSE);
2760       else
2761          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2762                TRUE);
2763       if(BuildULTnlInforet != ROK)
2764       {
2765          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2766          return RFAILED;
2767       }
2768
2769       /*RLCMode*/
2770       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2771       {
2772          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2773          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2774       }
2775       else
2776          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2777
2778       /* DL PDCP SN Length */
2779       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2780       {
2781          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2782          if(!drbToBeSetupExt)
2783          {
2784             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2785             return RFAILED;
2786          }
2787
2788          elementCnt = 1;
2789          drbToBeSetupExt->list.count = elementCnt;
2790          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
2791
2792          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
2793          if(!drbToBeSetupExt->list.array)
2794          {
2795              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
2796              return RFAILED;
2797          }
2798
2799          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
2800          {
2801             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
2802             if(!drbToBeSetupExt->list.array[extIeIdx])
2803             {
2804                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
2805                return RFAILED;
2806             }
2807          }
2808
2809          extIeIdx = 0;
2810          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
2811
2812          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
2813          drbToBeSetupExtIe->criticality = Criticality_ignore;
2814          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
2815          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
2816          drbSetItem->iE_Extensions = drbToBeSetupExt;
2817       }
2818
2819       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2820          ueCb->numDrb++;
2821    }
2822    return ROK;
2823 }/* End of BuildDRBSetup*/
2824
2825 /*******************************************************************
2826  *
2827  * @brief Deallocating memory of function BuildAndSendUESetReq
2828  *
2829  * @details
2830  *
2831  *    Function : FreeNrcgi
2832  *
2833  *    Functionality: Deallocating memory for function BuildNrcgi
2834  *
2835  * @params[in] NRCGI_t *nrcgi
2836  *
2837  * @return void
2838  *
2839  *******************************************************************/
2840 void FreeNrcgi(NRCGI_t *nrcgi)
2841 {
2842    if(nrcgi->pLMN_Identity.buf != NULLP)
2843    {
2844       if(nrcgi->nRCellIdentity.buf != NULLP)
2845       {
2846          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2847       }
2848       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2849    }
2850 }
2851 /*******************************************************************
2852  *
2853  * @brief  Deallocating memory of function BuildAndSendUESetReq
2854  *
2855  * @details
2856  *
2857  *    Function : FreeSplCellList
2858  *
2859  *    Functionality: Deallocating memory for function BuildSplCellList
2860  *
2861  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2862  *
2863  * @return void
2864  *
2865  *
2866  * *****************************************************************/
2867 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2868 {
2869    uint8_t  cellidx;
2870    if(spCellLst->list.array != NULLP)
2871    {
2872       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2873       {
2874          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2875          {
2876             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2877          }
2878          if(spCellLst->list.array[cellidx]!=NULLP)
2879          {
2880             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2881          }
2882       }
2883       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2884    }
2885 }
2886 /*******************************************************************
2887  *
2888  * @brief Deallocating memory of function BuildAndSendUESetReq
2889  *
2890  * @details
2891  *
2892  *    Function : FreeSRBSetup
2893  *
2894  *    Functionality: Deallocating memory for function BuildSRBSetup
2895  *
2896  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2897  *
2898  * @return void
2899  *
2900  *
2901  * ******************************************************************/
2902 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2903 {
2904    uint8_t srbidx;
2905    if(srbSet->list.array != NULLP)
2906    {
2907       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2908       {
2909          if(srbSet->list.array[srbidx]!=NULLP)
2910          {
2911             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2912          }
2913       }
2914       CU_FREE(srbSet->list.array,srbSet->list.size);
2915    }
2916 }
2917 /*******************************************************************
2918  *
2919  * @brief Deallocating memory of function BuildAndSendUESetReq
2920  *
2921  * @details
2922  *
2923  *    Function : FreeQOSInfo
2924  *
2925  *    Functionality:  Deallocating memory for function BuildQOSInfo
2926  *
2927  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2928  *
2929  * @return void
2930  *
2931  * ****************************************************************/
2932 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2933 {
2934    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2935    uint8_t qosCntIdx = 0;
2936
2937    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2938    {
2939       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2940       {
2941          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2942          {
2943             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2944                   sizeof(MaxDataBurstVolume_t));
2945          }
2946          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2947                sizeof(AveragingWindow_t));
2948       }
2949       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2950             sizeof(NonDynamic5QIDescriptor_t));
2951    }
2952    if(drbQos->iE_Extensions)
2953    {
2954       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2955       if(qosIeExt->list.array != NULLP)
2956       {
2957          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2958          {
2959             if(qosIeExt->list.array[qosCntIdx])
2960             {
2961                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2962             }
2963          }
2964          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2965       }
2966
2967       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2968    }
2969 }
2970 /*******************************************************************
2971  *
2972  * @brief Deallocating memory of function BuildAndSendUESetReq
2973  *
2974  * @details
2975  *
2976  *    Function : FreeULTnlInfo
2977  *
2978  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2979  *
2980  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2981  *
2982  * @return void
2983  *
2984
2985  * ****************************************************************/
2986 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2987 {
2988    uint8_t ulidx=0;
2989    if(ulInfo->list.array != NULLP)
2990    {
2991       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2992       {
2993          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2994          {
2995             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2996             {
2997                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2998                      transportLayerAddress.buf != NULLP)
2999                {
3000                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3001                         !=NULLP)
3002                   {
3003                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3004                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3005                            gTPTunnel->gTP_TEID.size);
3006                   }
3007                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3008                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3009                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3010                }
3011                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3012                      sizeof(GTPTunnel_t));
3013             }
3014          }
3015          if(ulInfo->list.array[ulidx]!=NULLP)
3016          {
3017             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3018          }
3019       }
3020       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3021    }
3022 }
3023 /*******************************************************************
3024  *
3025  * @brief Deallocating memory for BuildAndSendUESetReq
3026  *
3027  * @details
3028  *
3029  *    Function : FreeDRBSetup
3030  *
3031  *    Functionality:  Deallocating memory for BuildDRBSetup
3032  *
3033  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3034  *
3035  * @return void
3036  *
3037  * ****************************************************************/
3038 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3039 {
3040    DRBs_ToBeSetup_Item_t *drbSetItem;
3041    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3042
3043    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3044
3045    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3046    if(drbSet->list.array != NULLP)
3047    {
3048       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3049       {
3050               if(drbSet->list.array[drbidx] != NULLP)
3051               {
3052                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3053                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3054                  {
3055                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3056                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3057                {
3058                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3059                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3060                             {
3061                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3062                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3063                                {
3064                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3065                                        {
3066                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3067                                           {
3068                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3069                                              {
3070                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3071                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3072                                                      {
3073                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3074                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3075                                                          {
3076                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3077                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3078                                                              {
3079                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3080                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3081                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=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->averagingWindow!=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->maxDataBurstVolume!=NULLP)
3090                                                                                   {
3091                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3092                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3093
3094                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3095                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3096                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3097                                                                                                    sizeof(MaxDataBurstVolume_t));
3098                                                                                   }
3099                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3100                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3101                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_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,sizeof(NonDynamic5QIDescriptor_t));
3106                                                                      }
3107                                                             }
3108                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3109                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3110                                                             {
3111                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3112                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3113                                                             }
3114                                                         }
3115                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3116                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3117                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3118                                                      }
3119                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3120                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3121                                             }
3122                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3123                                                               sizeof(OCTET_STRING_t));
3124                                        }
3125                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3126                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3127                                     }
3128                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3129                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3130                             }
3131                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3132                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3133                          }
3134                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3135                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3136              }
3137              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3138                         iE_Extensions != NULLP)
3139              {
3140                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3141                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3142                  if(qosIeExt->list.array != NULLP)
3143                  {
3144                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3145                    {
3146                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3147                       {
3148                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3149                       }
3150                     }
3151                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3152                   }
3153                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3154                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3155               }
3156
3157                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3158                 }
3159                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3160               }
3161       }
3162       CU_FREE(drbSet->list.array,drbSet->list.size);
3163    }
3164 }
3165
3166
3167 /*******************************************************************
3168  *
3169  * @brief Free the UE Setup Request
3170  *
3171  * @details
3172  *
3173  *    Function : FreeUeContextSetupReq
3174  *
3175  *    Functionality: Deallocate the memory of BuildUESetReq
3176  *
3177  * @params[in]  F1AP_PDU_t  *f1apMsg
3178  *
3179  * @return void
3180  *
3181  *
3182  * ****************************************************************/
3183 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3184 {
3185    uint8_t idx, ieId;
3186    UEContextSetupRequest_t  *ueSetReq = NULLP;
3187
3188    if(f1apMsg != NULLP)
3189    {
3190       if(f1apMsg->choice.initiatingMessage != NULLP)
3191       {
3192          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3193          if(ueSetReq->protocolIEs.list.array != NULLP)
3194          {
3195             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3196             {
3197                if(ueSetReq->protocolIEs.list.array[idx])
3198                {
3199                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3200                   {
3201                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3202                         break;
3203                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3204                         break;
3205                      case ProtocolIE_ID_id_SpCell_ID:
3206                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3207                         break;
3208                      case ProtocolIE_ID_id_ServCellIndex:
3209                         break;
3210                      case ProtocolIE_ID_id_SpCellULConfigured:
3211                         break;
3212                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3213                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3214                         break;
3215                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3216                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3217                         break;
3218                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3219                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3220                         break;
3221                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3222                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3223                         break;
3224                      case ProtocolIE_ID_id_RRCContainer:
3225                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3226                         {
3227                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3228                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3229                         }
3230                         break;
3231                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3232                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3233                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3234                         break;
3235                      default:
3236                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3237                         break;
3238                   }
3239                }
3240                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3241             }
3242             for(ieId=0; ieId<idx; ieId++)
3243             {
3244                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3245                {
3246                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3247                }
3248             }
3249             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3250          }
3251          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3252       }
3253       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3254    }
3255 }
3256
3257 /**Filling cell group info **/
3258 /*******************************************************************
3259  *
3260  * @brief Build Control resource set to add/modify list
3261  *
3262  * @details
3263  *
3264  *    Function : BuildControlRSetToAddModList
3265  *
3266  *    Functionality: Build Control resource set to add/modify list
3267  *
3268  * @params[in]
3269  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3270  *
3271  * @return ROK     - success
3272  *         RFAILED - failure
3273  *
3274  * ****************************************************************/
3275    uint8_t BuildControlRSetToAddModList
3276 (
3277  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3278  )
3279 {
3280    uint8_t idx;
3281    uint8_t elementCnt;
3282    uint8_t numBytes, bitsUnused;
3283    struct ControlResourceSet *controlRSet;
3284    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3285    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3286
3287    elementCnt = 1;
3288    controlRSetList->list.count = elementCnt;
3289    controlRSetList->list.size = \
3290                                 elementCnt * sizeof(struct ControlResourceSet *);
3291
3292    controlRSetList->list.array = NULLP;
3293    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3294    if(!controlRSetList->list.array)
3295    {
3296       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3297       return RFAILED;
3298    }
3299
3300    for(idx = 0; idx < elementCnt; idx++)
3301    {
3302       controlRSetList->list.array[idx] = NULLP;
3303       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3304       if(!controlRSetList->list.array[idx])
3305       {
3306          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3307          return RFAILED;
3308       }
3309    }
3310
3311    idx=0;
3312    controlRSet = controlRSetList->list.array[idx];
3313    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3314
3315    /* Values harcoded according to our design:
3316     * size 6 bytes
3317     * 3 LSBs unsued
3318     * Bit string stored ff0000000000
3319     */
3320    numBytes = 6;
3321    bitsUnused = 3;
3322    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3323    controlRSet->frequencyDomainResources.buf = NULLP;
3324    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3325          controlRSet->frequencyDomainResources.size);
3326    if(!controlRSet->frequencyDomainResources.buf)
3327    {
3328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3329       return RFAILED;
3330    }
3331
3332    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3333    coreset0EndPrb = CORESET0_END_PRB;
3334    coreset1StartPrb = coreset0EndPrb + 6;
3335    coreset1NumPrb = CORESET1_NUM_PRB;
3336    /* calculate the PRBs */
3337    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3338    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3339    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3340
3341    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3342    controlRSet->cce_REG_MappingType.present = \
3343                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3344
3345    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3346    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3347    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3348    controlRSet->tci_PresentInDCI = NULLP;
3349 #if 0
3350    uint8_t tciStateIdx;
3351
3352    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3353          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3354    if(!controlRset->tci_StatesPDCCH_ToAddList)
3355    {
3356       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3357       return RFAILED;
3358    }
3359
3360    elementCnt = 1;
3361    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3362    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3363    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3364          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3365       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3366       {
3367          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3368          return RFAILED;
3369       }
3370
3371    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3372    {
3373       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3374       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3375       {
3376          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3377          return RFAILED;
3378       }
3379    }
3380
3381    tciStateIdx = 0;
3382    /* TODO */
3383    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3384
3385    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3386    if(!controlRset->tci_PresentInDCI)
3387    {
3388       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3389       return RFAILED;
3390    }
3391    /* TODO */
3392    *(controlRset->tci_PresentInDCI);
3393 #endif
3394
3395    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3396    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3397    if(!controlRSet->pdcch_DMRS_ScramblingID)
3398    {
3399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3400       return RFAILED;
3401    }
3402    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3403
3404    return ROK;
3405 } /* End BuildControlRSetToAddModList */
3406
3407 /*******************************************************************
3408  *
3409  * @brief Build search space to add/modify list
3410  *
3411  * @details
3412  *
3413  *    Function : BuildSearchSpcToAddModList
3414  *
3415  *    Functionality: Build search space to add/modify list
3416  *
3417  * @params[in]
3418  * @return ROK     - success
3419  *         RFAILED - failure
3420  *
3421  * ****************************************************************/
3422    uint8_t BuildSearchSpcToAddModList
3423 (
3424  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3425  )
3426 {
3427    uint8_t idx;
3428    uint8_t numBytes;
3429    uint8_t byteIdx;
3430    uint8_t bitsUnused;
3431    uint8_t elementCnt;
3432    struct SearchSpace *searchSpc;
3433
3434    elementCnt = 1;
3435    searchSpcList->list.count = elementCnt;
3436    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3437
3438    searchSpcList->list.array = NULLP;
3439    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3440    if(!searchSpcList->list.array)
3441    {
3442       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3443       return RFAILED;
3444    }
3445
3446    for(idx = 0; idx < elementCnt; idx++)
3447    {
3448       searchSpcList->list.array[idx] = NULLP;
3449       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3450       if(!searchSpcList->list.array[idx])
3451       {
3452          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3453          return RFAILED;
3454       }
3455    }
3456
3457    idx = 0;
3458    searchSpc = searchSpcList->list.array[idx];
3459
3460    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3461
3462    searchSpc->controlResourceSetId = NULLP;
3463    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3464    if(!searchSpc->controlResourceSetId)
3465    {
3466       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3467       return RFAILED;
3468    }
3469    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3470
3471    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3472    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3473          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3474    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3475    {
3476       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3477       return RFAILED;
3478    }
3479    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3480                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3481
3482    searchSpc->duration = NULLP;
3483    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3484    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3485    if(!searchSpc->monitoringSymbolsWithinSlot)
3486    {
3487       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3488       return RFAILED;
3489    }
3490
3491    /* Values taken from reference logs :
3492     * size 2 bytes
3493     * 2 LSBs unsued
3494     * Bit string stores 8000
3495     */
3496    numBytes = 2;
3497    bitsUnused = 2;
3498
3499    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3500    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3501    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3502          searchSpc->monitoringSymbolsWithinSlot->size);
3503    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3504    {
3505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3506       return RFAILED;
3507    }
3508
3509    byteIdx = 0;
3510    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3511                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3512    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3513    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3514
3515    searchSpc->nrofCandidates = NULLP;
3516    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3517    if(!searchSpc->nrofCandidates)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3520       return RFAILED;
3521    }
3522
3523    searchSpc->nrofCandidates->aggregationLevel1 = \
3524                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3525    searchSpc->nrofCandidates->aggregationLevel2 = \
3526                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3527    searchSpc->nrofCandidates->aggregationLevel4 = \
3528                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3529    searchSpc->nrofCandidates->aggregationLevel8 = \
3530                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3531    searchSpc->nrofCandidates->aggregationLevel16 = \
3532                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3533
3534    searchSpc->searchSpaceType = NULLP;
3535    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3536    if(!searchSpc->searchSpaceType)
3537    {
3538       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3539       return RFAILED;
3540    }
3541
3542    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3543
3544    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3545    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3546          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3547    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3548    {
3549       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3550       return RFAILED;
3551    }
3552    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3553                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3554
3555    return ROK;
3556 }/* End BuildSearchSpcToAddModList */
3557
3558 /*******************************************************************
3559  *
3560  * @brief Builds BWP DL dedicated PDCCH config
3561  *
3562  * @details
3563  *
3564  *    Function : BuildBWPDlDedPdcchCfg
3565  *
3566  *    Functionality: Builds BWP DL dedicated PDCCH config
3567  *
3568  * @params[in] struct PDCCH_Config *pdcchCfg
3569  *
3570  * @return ROK     - success
3571  *         RFAILED - failure
3572  *
3573  * ****************************************************************/
3574 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3575 {
3576    pdcchCfg->controlResourceSetToAddModList = NULLP;
3577    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3578          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3579    if(!pdcchCfg->controlResourceSetToAddModList)
3580    {
3581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3582       return RFAILED;
3583    }
3584
3585    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3586    {
3587       return RFAILED;
3588    }
3589
3590    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3591
3592    pdcchCfg->searchSpacesToAddModList = NULLP;
3593    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3594          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3595    if(!pdcchCfg->searchSpacesToAddModList)
3596    {
3597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3598       return RFAILED;
3599    }
3600
3601    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3602    {
3603       return RFAILED;
3604    }
3605
3606    pdcchCfg->searchSpacesToReleaseList = NULLP;
3607    pdcchCfg->downlinkPreemption = NULLP;
3608    pdcchCfg->tpc_PUSCH = NULLP;
3609    pdcchCfg->tpc_PUCCH = NULLP;
3610    pdcchCfg->tpc_SRS = NULLP;
3611
3612    return ROK;
3613 }
3614
3615 /*******************************************************************
3616  *
3617  * @brief Builds DMRS DL PDSCH Mapping type A
3618  *
3619  * @details
3620  *
3621  *    Function : BuildDMRSDLPdschMapTypeA
3622  *
3623  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3624  *
3625  * @params[in]
3626  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3627  * @return ROK     - success
3628  *         RFAILED - failure
3629  *
3630  * ****************************************************************/
3631    uint8_t BuildDMRSDLPdschMapTypeA
3632 (
3633  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3634  )
3635 {
3636    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3637    dmrsDlCfg->choice.setup = NULLP;
3638    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3639    if(!dmrsDlCfg->choice.setup)
3640    {
3641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3642       return RFAILED;
3643    }
3644
3645    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3646    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3647    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3648    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3649    {
3650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3651       return RFAILED;
3652    }
3653    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3654
3655    dmrsDlCfg->choice.setup->maxLength = NULLP;
3656    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3657    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3658    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3659
3660    return ROK;
3661 }
3662
3663 /*******************************************************************
3664  *
3665  * @brief Builds TCI states to add/modify list
3666  *
3667  * @details
3668  *
3669  *    Function : BuildTCIStatesToAddModList
3670  *
3671  *    Functionality:Builds TCI states to add/modify list
3672  *
3673  * @params[in]
3674  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3675  *
3676  * @return ROK     - success
3677  *         RFAILED - failure
3678  *
3679  * ****************************************************************/
3680 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3681 {
3682    return ROK;
3683 }
3684
3685 /*******************************************************************
3686  *
3687  * @brief Builds PDSCH time domain allocation list
3688  *
3689  * @details
3690  *
3691  *    Function : BuildPdschTimeDomAllocList
3692  *
3693  *    Functionality: Builds PDSCH time domain allocation list
3694  *
3695  * @params[in]
3696  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3697  *
3698  * @return ROK     - success
3699  *         RFAILED - failure
3700  *
3701  * ****************************************************************/
3702    uint8_t BuildPdschTimeDomAllocList
3703 (
3704  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3705  )
3706 {
3707    uint8_t idx;
3708    uint8_t elementCnt;
3709    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3710
3711    timeDomAllocList->present = \
3712                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3713
3714    timeDomAllocList->choice.setup = NULLP;
3715    CU_ALLOC(timeDomAllocList->choice.setup, \
3716          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3717    if(!timeDomAllocList->choice.setup)
3718    {
3719       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3720       return RFAILED;
3721    }
3722
3723    elementCnt = 2;
3724    timeDomAllocList->choice.setup->list.count = elementCnt;
3725    timeDomAllocList->choice.setup->list.size = \
3726                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3727
3728    timeDomAllocList->choice.setup->list.array = NULLP;
3729    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3730          timeDomAllocList->choice.setup->list.size);
3731    if(!timeDomAllocList->choice.setup->list.array)
3732    {
3733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3734       return RFAILED;
3735    }
3736
3737    for(idx = 0; idx < elementCnt; idx++)
3738    {
3739       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3740       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3741             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3742       if(!timeDomAllocList->choice.setup->list.array[idx])
3743       {
3744          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3745          return RFAILED;
3746       }
3747    }
3748
3749    idx = 0;
3750    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3751    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3752    if(!timeDomAlloc->k0)
3753    {
3754        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3755        return RFAILED;
3756    }
3757    *(timeDomAlloc->k0) = 0;
3758    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3759    timeDomAlloc->startSymbolAndLength = 66;
3760
3761    idx++;
3762    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3763    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3764    if(!timeDomAlloc->k0)
3765    {
3766       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3767       return RFAILED;
3768    }
3769    *(timeDomAlloc->k0) = 1;
3770    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3771    timeDomAlloc->startSymbolAndLength = 66;
3772
3773    return ROK;
3774 }
3775
3776 /*******************************************************************
3777  *
3778  * @brief Builds PDSCH PRB Bundling type
3779  *
3780  * @details
3781  *
3782  *    Function : BuildPdschPrbBundlingType
3783  *
3784  *    Functionality: Builds PDSCH PRB Bundling type
3785  *
3786  * @params[in]
3787  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3788  *
3789  * @return ROK     - success
3790  *         RFAILED - failure
3791  *
3792  * ****************************************************************/
3793    uint8_t BuildPdschPrbBundlingType
3794 (
3795  struct PDSCH_Config__prb_BundlingType *prbBndlType
3796  )
3797 {
3798    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3799
3800    prbBndlType->choice.staticBundling = NULLP;
3801    CU_ALLOC(prbBndlType->choice.staticBundling, \
3802          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3803    if(!prbBndlType->choice.staticBundling)
3804    {
3805       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3806       return RFAILED;
3807    }
3808    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3809
3810    return ROK;
3811 }
3812
3813 /*******************************************************************
3814  *
3815  * @brief Builds BWP DL dedicated PDSCH config
3816  *
3817  * @details
3818  *
3819  *    Function : BuildBWPDlDedPdschCfg
3820  *
3821  *    Functionality: Builds BWP DL dedicated PDSCH config
3822  *
3823  * @params[in] struct PDSCH_Config *pdschCfg
3824  *
3825  * @return ROK     - success
3826  *         RFAILED - failure
3827  *
3828  * ****************************************************************/
3829 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3830 {
3831    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3832
3833    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3834    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3835          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3836    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3837    {
3838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3839       return RFAILED;
3840    }
3841
3842    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3843    {
3844       return RFAILED;
3845    }
3846
3847    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3848    pdschCfg->tci_StatesToAddModList = NULLP;
3849    pdschCfg->tci_StatesToReleaseList = NULLP;
3850    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3851 #if 0
3852    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3853    if(!pdschCfg->tci_StatesToAddModList)
3854    {
3855       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3856       return RFAILED;
3857    }
3858    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3859    {
3860       return RFAILED;
3861    }
3862 #endif
3863
3864    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3865
3866    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3867    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3868          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3869    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3870    {
3871       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3872       return RFAILED;
3873    }
3874    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3875    {
3876       return RFAILED;
3877    }
3878    pdschCfg->pdsch_AggregationFactor = NULLP;
3879    pdschCfg->rateMatchPatternToAddModList = NULLP;
3880    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3881    pdschCfg->rateMatchPatternGroup1 = NULLP;
3882    pdschCfg->rateMatchPatternGroup2 = NULLP;
3883    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3884    pdschCfg->mcs_Table = NULLP;
3885
3886    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3887    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3888    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3889    {
3890       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3891       return RFAILED;
3892    }
3893    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3894
3895    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3896    {
3897       return RFAILED;
3898    }
3899
3900    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3901    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3902    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3903    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3904    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3905    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3906    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3907
3908    return ROK;
3909 }
3910
3911 /*******************************************************************
3912  *
3913  * @brief Builds intitial DL BWP
3914  * @details
3915  *
3916  *    Function : BuildInitialDlBWP
3917  *
3918  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3919  *
3920  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3921  *
3922  * @return ROK     - success
3923  *         RFAILED - failure
3924  *
3925  * ****************************************************************/
3926 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3927 {
3928    dlBwp->pdcch_Config = NULLP;
3929    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3930    if(!dlBwp->pdcch_Config)
3931    {
3932       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3933       return RFAILED;
3934    }
3935    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3936
3937    dlBwp->pdcch_Config->choice.setup = NULLP;
3938    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3939    if(!dlBwp->pdcch_Config->choice.setup)
3940    {
3941       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3942       return RFAILED;
3943    }
3944    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3945    {
3946       return RFAILED;
3947    }
3948
3949    dlBwp->pdsch_Config = NULLP;
3950    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3951    if(!dlBwp->pdsch_Config)
3952    {
3953       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3954       return RFAILED;
3955    }
3956    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3957
3958    dlBwp->pdsch_Config->choice.setup = NULLP;
3959    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3960    if(!dlBwp->pdsch_Config->choice.setup)
3961    {
3962       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3963       return RFAILED;
3964    }
3965
3966    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3967    {
3968       return RFAILED;
3969    }
3970
3971    dlBwp->sps_Config = NULLP;
3972    dlBwp->radioLinkMonitoringConfig = NULLP;
3973    return ROK;
3974 }
3975
3976 /*******************************************************************
3977  *
3978  * @brief Builds DMRS UL Pusch Mapping type A
3979  *
3980  * @details
3981  *
3982  *    Function : BuildDMRSULPuschMapTypeA
3983  *
3984  *    Functionality: Builds DMRS UL Pusch Mapping type A
3985  *
3986  * @params[in]
3987  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3988  * @return ROK     - success
3989  *         RFAILED - failure
3990  *
3991  * ****************************************************************/
3992    uint8_t BuildDMRSULPuschMapTypeA
3993 (
3994  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3995  )
3996 {
3997    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3998    dmrsUlCfg->choice.setup= NULLP;
3999    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4000    if(!dmrsUlCfg->choice.setup)
4001    {
4002       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4003       return RFAILED;
4004    }
4005
4006    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4007    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4008    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4009    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4010    {
4011       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4012       return RFAILED;
4013    }
4014    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4015
4016    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4017    dmrsUlCfg->choice.setup->maxLength = NULLP;
4018    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4019    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4020          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4021    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4022    {
4023       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4024       return RFAILED;
4025    }
4026
4027    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4028    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4029          sizeof(long));
4030    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4031    {
4032       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4033       return RFAILED;
4034    }
4035    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4036
4037    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4038    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4039    return ROK;
4040 }
4041
4042 /*******************************************************************
4043  *
4044  * @brief Build PUSCH time domain allocation list
4045  *
4046  * @details
4047  *
4048  *    Function : BuildPuschTimeDomAllocList
4049  *
4050  *    Functionality: Build PUSCH time domain allocation list
4051  *
4052  * @params[in]
4053  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4054  *
4055  * @return ROK     - success
4056  *         RFAILED - failure
4057  *
4058  * ****************************************************************/
4059    uint8_t BuildPuschTimeDomAllocList
4060 (
4061  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4062  )
4063 {
4064    uint8_t idx;
4065    uint8_t elementCnt;
4066    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4067
4068    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4069    timeDomAllocList->choice.setup = NULLP;
4070    CU_ALLOC(timeDomAllocList->choice.setup, \
4071          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4072    if(!timeDomAllocList->choice.setup)
4073    {
4074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4075       return RFAILED;
4076    }
4077
4078    elementCnt = 2;
4079    timeDomAllocList->choice.setup->list.count = elementCnt;
4080    timeDomAllocList->choice.setup->list.size = \
4081                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4082    timeDomAllocList->choice.setup->list.array = NULLP;
4083    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4084          timeDomAllocList->choice.setup->list.size);
4085    if(!timeDomAllocList->choice.setup->list.array)
4086    {
4087       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4088       return RFAILED;
4089    }
4090
4091    for(idx = 0; idx < elementCnt; idx++)
4092    {
4093       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4094       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4095             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4096       if(!timeDomAllocList->choice.setup->list.array[idx])
4097       {
4098          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4099          return RFAILED;
4100       }
4101    }
4102
4103    idx = 0;
4104    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4105    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4106    if(!timeDomAlloc->k2)
4107    {
4108       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4109       return RFAILED;
4110    }
4111    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4112    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4113    timeDomAlloc->startSymbolAndLength = 66;
4114
4115    idx++;
4116    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4117    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4118    if(!timeDomAlloc->k2)
4119    {
4120        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4121        return RFAILED;
4122    }
4123    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4124    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4125    timeDomAlloc->startSymbolAndLength = 66;
4126
4127    return ROK;
4128 }
4129
4130 /*******************************************************************
4131  *
4132  * @brief Builds BWP UL dedicated PUSCH Config
4133  *
4134  * @details
4135  *
4136  *    Function : BuildBWPUlDedPuschCfg
4137  *
4138  *    Functionality:
4139  *      Builds BWP UL dedicated PUSCH Config
4140  *
4141  * @params[in] : PUSCH_Config_t *puschCfg
4142  *
4143  * @return ROK     - success
4144  *         RFAILED - failure
4145  *
4146  * ****************************************************************/
4147 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4148 {
4149    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4150    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4151    if(!puschCfg->dataScramblingIdentityPUSCH)
4152    {
4153       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4154       return RFAILED;
4155    }
4156    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4157
4158    puschCfg->txConfig = NULLP;
4159    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4160    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4161          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4162    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4163    {
4164       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4165       return RFAILED;
4166    }
4167
4168    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4169    {
4170       return RFAILED;
4171    }
4172
4173    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4174    puschCfg->pusch_PowerControl = NULLP;
4175    puschCfg->frequencyHopping = NULLP;
4176    puschCfg->frequencyHoppingOffsetLists = NULLP;
4177    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4178
4179    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4180    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4181          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4182    if(!puschCfg->pusch_TimeDomainAllocationList)
4183    {
4184       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4185       return RFAILED;
4186    }
4187
4188    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4189    {
4190       return RFAILED;
4191    }
4192
4193    puschCfg->pusch_AggregationFactor = NULLP;
4194    puschCfg->mcs_Table = NULLP;
4195    puschCfg->mcs_TableTransformPrecoder = NULLP;
4196    puschCfg->transformPrecoder = NULLP;
4197    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4198    if(!puschCfg->transformPrecoder)
4199    {
4200       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4201       return RFAILED;
4202    }
4203    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4204
4205    puschCfg->codebookSubset = NULLP;
4206    puschCfg->maxRank = NULLP;
4207    puschCfg->rbg_Size = NULLP;
4208    puschCfg->uci_OnPUSCH = NULLP;
4209    puschCfg->tp_pi2BPSK = NULLP;
4210
4211    return ROK;
4212 }
4213
4214 /*******************************************************************
4215  *
4216  * @brief Builds BWP UL dedicated PUCCH Config
4217  *
4218  * @details
4219  *
4220  *    Function : BuildBWPUlDedPucchCfg
4221  *
4222  *    Functionality:
4223  *      Builds BWP UL dedicated PUCCH Config
4224  *
4225  * @params[in] : PUCCH_Config_t *pucchCfg
4226  *
4227  * @return ROK     - success
4228  *         RFAILED - failure
4229  *
4230  * ****************************************************************/
4231 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4232 {
4233    uint8_t arrIdx, elementCnt;
4234    uint8_t rsrcIdx, rsrcSetIdx;
4235    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4236    PUCCH_Resource_t *rsrc = NULLP;
4237
4238    //RESOURCE SET
4239    elementCnt = 1;
4240    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4241    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4242    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4243    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4244    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4245    {
4246       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4247    }
4248    rsrcSetIdx = 0;
4249    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4250    rsrcSet->pucch_ResourceSetId = 1;
4251    elementCnt = 1;
4252    rsrcSet->resourceList.list.count = elementCnt;
4253    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4254    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4255    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4256    {
4257       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4258    }
4259    rsrcIdx = 0;
4260    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4261
4262    //RESOURCE
4263    elementCnt = 1;
4264    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4265    pucchCfg->resourceToAddModList->list.count = elementCnt;
4266    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4267    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4268    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4269    {
4270       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4271    }
4272    rsrcIdx = 0;
4273    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4274    rsrc->pucch_ResourceId = 1;
4275    rsrc->startingPRB = 0;
4276    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4277    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4278    rsrc->format.choice.format1->initialCyclicShift = 0;
4279    rsrc->format.choice.format1->nrofSymbols = 4;
4280    rsrc->format.choice.format1->startingSymbolIndex = 0;
4281    rsrc->format.choice.format1->timeDomainOCC = 0;
4282
4283    //PUCCH Format 1
4284    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4285    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4286    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4287    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4288    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4289
4290    //DL DATA TO UL ACK
4291    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4292    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4293    {
4294       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4295       return RFAILED;
4296    }
4297
4298    elementCnt = 2;
4299    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4300    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4301    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4302    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4303    {
4304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4305       return RFAILED;
4306    }
4307
4308    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4309    {
4310       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4311       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4312       {
4313           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4314           return RFAILED;
4315       }
4316    }
4317
4318    arrIdx = 0;
4319    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4320    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4321
4322    return ROK;
4323 }
4324
4325 /*******************************************************************
4326  *
4327  * @brief Fills SRS resource to add/modify list
4328  *
4329  * @details
4330  *
4331  *    Function : BuildSrsRsrcAddModList
4332  *
4333  *    Functionality: Fills SRS resource to add/modify list
4334  *
4335  * @params[in]
4336  * @return ROK     - success
4337  *         RFAILED - failure
4338  *
4339  * ****************************************************************/
4340 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4341 {
4342    uint8_t   elementCnt;
4343    uint8_t   rsrcIdx;
4344
4345    elementCnt = 1;
4346    resourceList->list.count = elementCnt;
4347    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4348    resourceList->list.array = NULLP;
4349    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4350    if(!resourceList->list.array)
4351    {
4352       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4353       return RFAILED;
4354    }
4355
4356    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4357    {
4358       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4359       if(!resourceList->list.array[rsrcIdx])
4360       {
4361          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4362          return RFAILED;
4363       }
4364    }
4365
4366    rsrcIdx = 0;
4367    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4368    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4369    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4370
4371    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4372    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4373          sizeof(struct SRS_Resource__transmissionComb__n2));
4374    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4377       return RFAILED;
4378    }
4379    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4380       = SRS_COMB_OFFSET_N2;
4381    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4382       = SRS_CYCLIC_SHIFT_N2;
4383
4384    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4385    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4386                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4387    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4388                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4389
4390    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4391    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4392    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4393    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4394    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4395    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4396                                                                SRS_Resource__groupOrSequenceHopping_neither;
4397
4398    /* Setting resource type to aperiodic for intergration purposes */
4399    resourceList->list.array[rsrcIdx]->resourceType.present = \
4400                                                              SRS_Resource__resourceType_PR_aperiodic;
4401    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4402    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4403          sizeof(struct SRS_Resource__resourceType__aperiodic));
4404    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4405    {
4406       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4407       return RFAILED;
4408    }
4409    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4410
4411    return ROK;
4412 }
4413
4414 /*******************************************************************
4415  *
4416  * @brief Build SRS resource set Add/mod list
4417  *
4418  * @details
4419  *
4420  *    Function : BuildSrsRsrcSetAddModList
4421  *
4422  *    Functionality: Build SRS resource set Add/mod list
4423  *
4424  * @params[in]
4425  * @return ROK     - success
4426  *         RFAILED - failure
4427  *
4428  * ****************************************************************/
4429    uint8_t BuildSrsRsrcSetAddModList
4430 (
4431  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4432  )
4433 {
4434    uint8_t  elementCnt;
4435    uint8_t  rSetIdx;
4436    uint8_t  rsrcIdx;
4437    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4438
4439    elementCnt = 1;
4440    rsrcSetList->list.count = elementCnt;
4441    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4442    rsrcSetList->list.array = NULLP;
4443    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4444    if(!rsrcSetList->list.array)
4445    {
4446       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4447       return RFAILED;
4448    }
4449
4450    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4451    {
4452       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4453       if(!rsrcSetList->list.array[rSetIdx])
4454       {
4455          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4456          return RFAILED;
4457       }
4458    }
4459
4460    rSetIdx = 0;
4461    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4462
4463    /* Fill Resource Id list in resource set */
4464    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4465    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4466          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4467    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4468    {
4469       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4470       return RFAILED;
4471    }
4472
4473    elementCnt = 1;
4474    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4475    rsrcIdList->list.count = elementCnt;
4476    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4477    rsrcIdList->list.array = NULLP;
4478    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4479    if(!rsrcIdList->list.array)
4480    {
4481       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4482       return RFAILED;
4483    }
4484
4485    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4486    {
4487       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4488       if(!rsrcIdList->list.array[rsrcIdx])
4489       {
4490          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4491          return RFAILED;
4492       }
4493    }
4494
4495    rsrcIdx = 0;
4496    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4497
4498    /* Fill resource type */
4499    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4500                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4501
4502    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4503    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4504          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4505    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4506    {
4507       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4508       return RFAILED;
4509    }
4510    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4511       = APERIODIC_SRS_RESRC_TRIGGER;
4512
4513    /* TODO : Fill values for below IEs as expected by Viavi */
4514    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4515    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4516
4517
4518    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4519    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4520    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4521    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4522    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4523
4524    return ROK;
4525 }
4526
4527 /*******************************************************************
4528  *
4529  * @brief Builds BWP UL dedicated SRS Config
4530  *
4531  * @details
4532  *
4533  *    Function : BuildBWPUlDedSrsCfg
4534  *
4535  *    Functionality: Builds BWP UL dedicated SRS Config
4536  *
4537  * @params[in] SRS Config
4538  * @return ROK     - success
4539  *         RFAILED - failure
4540  *
4541  * ****************************************************************/
4542 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4543 {
4544    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4545    srsCfg->srs_ResourceSetToAddModList = NULLP;
4546    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4547          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4548    if(!srsCfg->srs_ResourceSetToAddModList)
4549    {
4550       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4551       return RFAILED;
4552    }
4553    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4554    {
4555       return RFAILED;
4556    }
4557
4558    srsCfg->srs_ResourceToReleaseList = NULLP;
4559
4560    /* Resource to Add/Modify list */
4561    srsCfg->srs_ResourceToAddModList = NULLP;
4562    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4563          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4564    if(!srsCfg->srs_ResourceToAddModList)
4565    {
4566       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4567       return RFAILED;
4568    }
4569
4570    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4571    {
4572       return RFAILED;
4573    }
4574
4575    srsCfg->tpc_Accumulation = NULLP;
4576
4577    return ROK;
4578 }
4579
4580 /*******************************************************************
4581  *
4582  * @brief Builds inital UL BWP
4583  *
4584  * @details
4585  *
4586  *    Function : BuildInitialUlBWP
4587  *
4588  *    Functionality: Builds initial UL BWP
4589  *
4590  * @params[in] BWP_UplinkDedicated_t *ulBwp
4591  * @return ROK     - success
4592  *         RFAILED - failure
4593  *
4594  * ****************************************************************/
4595 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4596 {
4597    ulBwp->pucch_Config = NULLP;
4598    ulBwp->pucch_Config = NULLP;
4599    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4600    if(!ulBwp->pucch_Config)
4601    {
4602       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4603       return RFAILED;
4604    }
4605
4606    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4607    ulBwp->pucch_Config->choice.setup = NULLP;
4608    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4609    if(!ulBwp->pucch_Config->choice.setup)
4610    {
4611       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4612       return RFAILED;
4613    }
4614
4615    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4616    {
4617       return RFAILED;
4618    }
4619
4620    /* Fill BWP UL dedicated PUSCH config */
4621    ulBwp->pusch_Config = NULLP;
4622    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4623    if(!ulBwp->pusch_Config)
4624    {
4625       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4626       return RFAILED;
4627    }
4628
4629    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4630    ulBwp->pusch_Config->choice.setup = NULLP;
4631    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4632    if(!ulBwp->pusch_Config->choice.setup)
4633    {
4634       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4635       return RFAILED;
4636    }
4637
4638    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4639    {
4640       return RFAILED;
4641    }
4642
4643    ulBwp->configuredGrantConfig = NULLP;
4644
4645    /* Fill BPW UL dedicated SRS config */
4646    ulBwp->srs_Config = NULLP;
4647    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4648    if(!ulBwp->srs_Config)
4649    {
4650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4651       return RFAILED;
4652    }
4653
4654    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4655    ulBwp->srs_Config->choice.setup = NULLP;
4656    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4657    if(!ulBwp->srs_Config->choice.setup)
4658    {
4659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4660       return RFAILED;
4661    }
4662
4663    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4664    {
4665       return RFAILED;
4666    }
4667
4668    ulBwp->beamFailureRecoveryConfig = NULLP;
4669
4670    return ROK;
4671 }
4672
4673 /*******************************************************************
4674  *
4675  * @brief Builds Pusch Serving cell Config
4676  *
4677  * @details
4678  *
4679  *    Function : BuildPuschSrvCellCfg
4680  *
4681  *    Functionality: Builds Pusch Serving cell Config
4682  *
4683  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4684  *
4685  * @return ROK     - success
4686  *         RFAILED - failure
4687  *
4688  * ****************************************************************/
4689 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4690 {
4691    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4692    puschCfg->choice.setup = NULLP;
4693    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4694    if(!puschCfg->choice.setup)
4695    {
4696       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4697       return RFAILED;
4698    }
4699
4700    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4701    puschCfg->choice.setup->rateMatching = NULLP;
4702    puschCfg->choice.setup->xOverhead = NULLP;
4703    puschCfg->choice.setup->ext1 = NULLP;
4704    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4705    if(!puschCfg->choice.setup->ext1)
4706    {
4707       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4708       return RFAILED;
4709    }
4710
4711    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4712    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4713    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4714    {
4715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4716       return RFAILED;
4717    }
4718    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4719
4720    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4721    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4722    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4723    {
4724       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4725       return RFAILED;
4726    }
4727    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4728    return ROK;
4729 }
4730
4731 /*******************************************************************
4732  *
4733  * @brief Builds UL config
4734  * @details
4735  *
4736  *    Function : BuildUlCfg
4737  *
4738  *    Functionality: Builds UL config in spCellCfgDed
4739  *
4740  * @params[in] UplinkConfig_t *ulCfg
4741  *
4742  * @return ROK     - success
4743  *         RFAILED - failure
4744  *
4745  * ****************************************************************/
4746 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4747 {
4748    ulCfg->initialUplinkBWP = NULLP;
4749    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4750    if(!ulCfg->initialUplinkBWP)
4751    {
4752       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4753       return RFAILED;
4754    }
4755
4756    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4757    {
4758       return RFAILED;
4759    }
4760
4761    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4762    ulCfg->uplinkBWP_ToAddModList = NULLP;
4763    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4764    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4765    if(!ulCfg->firstActiveUplinkBWP_Id)
4766    {
4767       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4768       return RFAILED;
4769    }
4770    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4771
4772    ulCfg->pusch_ServingCellConfig = NULLP;
4773    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4774          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4775    if(!ulCfg->pusch_ServingCellConfig)
4776    {
4777       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4778       return RFAILED;
4779    }
4780
4781    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4782    {
4783       return RFAILED;
4784    }
4785
4786    ulCfg->carrierSwitching = NULLP;
4787    ulCfg->ext1 = NULLP;
4788    return ROK;
4789 }
4790
4791 /*******************************************************************
4792  *
4793  * @brief Builds PDSCH serving cell config
4794  * @details
4795  *
4796  *    Function : BuildPdschSrvCellCfg
4797  *
4798  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4799  *
4800  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4801  *
4802  * @return ROK     - success
4803  *         RFAILED - failure
4804  *
4805  * ****************************************************************/
4806 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4807 {
4808    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4809    pdschCfg->choice.setup = NULLP;
4810    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4811    if(!pdschCfg->choice.setup)
4812    {
4813       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4814       return RFAILED;
4815    }
4816
4817    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4818    pdschCfg->choice.setup->xOverhead = NULLP;
4819    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4820    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4821    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4822    {
4823       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4824       return RFAILED;
4825    }
4826    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4827    pdschCfg->choice.setup->pucch_Cell = NULLP;
4828    pdschCfg->choice.setup->ext1 = NULLP;
4829
4830    return ROK;
4831 }
4832
4833 /*******************************************************************
4834  *
4835  * @brief Builds CSI Meas config
4836  * @details
4837  *
4838  *    Function : BuildCsiMeasCfg
4839  *
4840  *    Functionality: Builds CSI Meas config in spCellCfgDed
4841  *
4842  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4843  *
4844  * @return ROK     - success
4845  *         RFAILED - failure
4846  *
4847  * ****************************************************************/
4848 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4849 {
4850
4851    return ROK;
4852 }
4853
4854 /*******************************************************************
4855  *
4856  * @brief Builds Spcell config dedicated
4857  * @details
4858  *
4859  *    Function : BuildSpCellCfgDed
4860  *
4861  *    Functionality: Builds sp cell config dedicated in spCellCfg
4862  *
4863  * @params[in] ServingCellConfig_t srvCellCfg
4864  *
4865  * @return ROK     - success
4866  *         RFAILED - failure
4867  *
4868  * ****************************************************************/
4869 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4870 {
4871    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4872
4873    srvCellCfg->initialDownlinkBWP = NULLP;
4874    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4875    if(!srvCellCfg->initialDownlinkBWP)
4876    {
4877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4878       return RFAILED;
4879    }
4880
4881    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4882    {
4883       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4884       return RFAILED;
4885    }
4886    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4887    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4888
4889    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4890    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4891    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4892    {
4893       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4894       return RFAILED;
4895    }
4896    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4897
4898    srvCellCfg->bwp_InactivityTimer = NULLP;
4899
4900    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4901    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4902    if(!srvCellCfg->defaultDownlinkBWP_Id)
4903    {
4904       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4905       return RFAILED;
4906    }
4907    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4908
4909    srvCellCfg->uplinkConfig = NULLP;
4910    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4911    if(!srvCellCfg->uplinkConfig)
4912    {
4913       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4914       return RFAILED;
4915    }
4916
4917    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4918    {
4919       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4920       return RFAILED;
4921    }
4922    srvCellCfg->supplementaryUplink = NULLP;
4923    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4924
4925    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4926    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4927    if(!srvCellCfg->pdsch_ServingCellConfig)
4928    {
4929       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4930       return RFAILED;
4931    }
4932
4933    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4934    {
4935       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4936       return RFAILED;
4937    }
4938
4939    srvCellCfg->csi_MeasConfig = NULLP;
4940 #if 0
4941    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4942       if(!srvCellCfg->csi_MeasConfig)
4943       {
4944          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4945          return RFAILED;
4946       }
4947
4948    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4949    {
4950       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4951       return RFAILED;
4952    }
4953 #endif
4954    srvCellCfg->sCellDeactivationTimer = NULLP;
4955    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4956    srvCellCfg->tag_Id = TAG_ID;
4957    srvCellCfg->dummy = NULLP;
4958    srvCellCfg->pathlossReferenceLinking = NULLP;
4959    srvCellCfg->servingCellMO = NULLP;
4960    srvCellCfg->ext1 = NULLP;
4961
4962    return ROK;
4963 }
4964 /*******************************************************************
4965  *
4966  * @brief Builds Spcell config
4967  *
4968  * @details
4969  *
4970  *    Function : BuildSpCellCfg
4971  *
4972  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4973  *
4974  * @params[in] SpCellConfig_t spCellCfg
4975  *
4976  * @return ROK     - success
4977  *         RFAILED - failure
4978  *
4979  * ****************************************************************/
4980 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4981 {
4982
4983    spCellCfg->servCellIndex = NULLP;
4984    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4985    if(!spCellCfg->servCellIndex)
4986    {
4987       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4988       return RFAILED;
4989    }
4990    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4991
4992    spCellCfg->reconfigurationWithSync = NULLP;
4993    spCellCfg->rlf_TimersAndConstants = NULLP;
4994    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4995    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4996    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4997    {
4998       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4999       return RFAILED;
5000    }
5001    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5002
5003    spCellCfg->spCellConfigDedicated = NULLP;
5004    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5005    if(!spCellCfg->spCellConfigDedicated)
5006    {
5007       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5008       return RFAILED;
5009    }
5010    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5011    {
5012       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5013       return RFAILED;
5014    }
5015    return ROK;
5016 }
5017 /*******************************************************************
5018  *
5019  * @brief Builds Phy cell group config
5020  *
5021  * @details
5022  *
5023  *    Function : BuildPhyCellGrpCfg
5024  *
5025  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5026  *
5027  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5028  *
5029  * @return ROK     - success
5030  *         RFAILED - failure
5031  *
5032  * ****************************************************************/
5033 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5034 {
5035    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5036    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5037
5038    phyCellGrpCfg->p_NR_FR1 = NULLP;
5039    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5040    if(!phyCellGrpCfg->p_NR_FR1)
5041    {
5042       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5043       return RFAILED;
5044    }
5045    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5046    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5047    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5048    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5049    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5050    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5051    phyCellGrpCfg->cs_RNTI = NULLP;
5052    phyCellGrpCfg->ext1 = NULLP;
5053    phyCellGrpCfg->ext2 = NULLP;
5054
5055    return ROK;
5056 }
5057
5058 /*******************************************************************
5059  *
5060  * @brief Builds tag config
5061  *
5062  * @details
5063  *
5064  *    Function : BuildTagConfig
5065  *
5066  *    Functionality: Builds tag config in MacCellGroupConfig
5067  *
5068  * @params[in] TAG_Config *tag_Config
5069  *
5070  * @return ROK     - success
5071  *         RFAILED - failure
5072  *
5073  * ****************************************************************/
5074 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5075 {
5076    struct TAG_Config__tag_ToAddModList *tagList;
5077    uint8_t                     idx, elementCnt;
5078
5079    tagConfig->tag_ToReleaseList = NULLP;
5080    tagConfig->tag_ToAddModList = NULLP;
5081    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5082    if(!tagConfig->tag_ToAddModList)
5083    {
5084       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5085       return RFAILED;
5086    }
5087
5088    elementCnt = 1; //ODU_VALUE_ONE;
5089    tagList = tagConfig->tag_ToAddModList;
5090    tagList->list.count = elementCnt;
5091    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5092
5093    tagList->list.array = NULLP;
5094    CU_ALLOC(tagList->list.array, tagList->list.size);
5095    if(!tagList->list.array)
5096    {
5097       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5098       return RFAILED;
5099    }
5100
5101    for(idx=0; idx<tagList->list.count; idx++)
5102    {
5103       tagList->list.array[idx] = NULLP;
5104       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5105       if(!tagList->list.array[idx])
5106       {
5107          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5108          return RFAILED;
5109       }
5110    }
5111
5112    idx = 0;
5113    tagList->list.array[idx]->tag_Id = TAG_ID;
5114    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5115
5116    return ROK;
5117 }
5118
5119 /*******************************************************************
5120  *
5121  * @brief Builds PHR Config
5122  *
5123  * @details
5124  *
5125  *    Function : BuildPhrConfig
5126  *
5127  *    Functionality: Builds phrConfig in MacCellGroupConfig
5128  *
5129  * @params[in] PHR Config *
5130  *
5131  * @return ROK     - success
5132  *         RFAILED - failure
5133  *
5134  * ****************************************************************/
5135 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5136 {
5137
5138    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5139    phrConfig->choice.setup = NULLP;
5140    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5141    if(!phrConfig->choice.setup)
5142    {
5143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5144       return RFAILED;
5145    }
5146
5147    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5148    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5149    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5150    phrConfig->choice.setup->multiplePHR              = false;
5151    phrConfig->choice.setup->dummy                    = false;
5152    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5153    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5154
5155    return ROK;
5156 }
5157
5158 /*******************************************************************
5159  *
5160  * @brief Builds BSR Config
5161  *
5162  * @details
5163  *
5164  *    Function : BuildBsrConfig
5165  *
5166  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5167  *
5168  * @params[in] BSR_Config *bsrConfig
5169  *
5170  * @return ROK     - success
5171  *         RFAILED - failure
5172  *
5173  * ****************************************************************/
5174 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5175 {
5176    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5177    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5178    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5179
5180    return ROK;
5181 }
5182
5183 /*******************************************************************
5184  *
5185  * @brief Builds scheduling request config
5186  *
5187  * @details
5188  *
5189  *    Function : BuildSchedulingReqConfig
5190  *
5191  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5192  *
5193  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5194  *
5195  * @return ROK     - success
5196  *         RFAILED - failure
5197  *
5198  * ****************************************************************/
5199 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5200 {
5201    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5202    uint8_t                     idx, elementCnt;
5203
5204    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5205    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5206          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5207    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5208    {
5209       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5210       return RFAILED;
5211    }
5212
5213    elementCnt = 1; //ODU_VALUE_ONE;
5214    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5215    schReqList->list.count = elementCnt;
5216    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5217
5218    schReqList->list.array = NULLP;
5219    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5220    if(!schReqList->list.array)
5221    {
5222       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5223       return RFAILED;
5224    }
5225
5226    for(idx=0;idx<schReqList->list.count; idx++)
5227    {
5228       schReqList->list.array[idx] = NULLP;
5229       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5230       if(!schReqList->list.array[idx])
5231       {
5232          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5233          return RFAILED;
5234       }
5235    }
5236
5237    idx = 0;
5238    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5239
5240    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5241    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5242    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5243    {
5244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5245       return RFAILED;
5246    }
5247    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5248    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5249    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5250
5251    return ROK;
5252 }
5253 /*******************************************************************
5254  *
5255  * @brief Builds Mac cell group config
5256  *
5257  * @details
5258  *
5259  *    Function : BuildMacCellGrpCfg
5260  *
5261  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5262  *
5263  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5264  *
5265  * @return ROK     - success
5266  *         RFAILED - failure
5267  *
5268  * ****************************************************************/
5269 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5270 {
5271    macCellGrpCfg->drx_Config = NULLP;
5272    macCellGrpCfg->schedulingRequestConfig = NULLP;
5273    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5274    if(!macCellGrpCfg->schedulingRequestConfig)
5275    {
5276       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5277       return RFAILED;
5278    }
5279
5280    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5281    {
5282       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5283       return RFAILED;
5284    }
5285
5286    macCellGrpCfg->bsr_Config = NULLP;
5287    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5288    if(!macCellGrpCfg->bsr_Config)
5289    {
5290       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5291       return RFAILED;
5292    }
5293
5294    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5295    {
5296       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5297       return RFAILED;
5298    }
5299
5300    macCellGrpCfg->tag_Config = NULLP;
5301    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5302    if(!macCellGrpCfg->tag_Config)
5303    {
5304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5305       return RFAILED;
5306    }
5307
5308    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5309    {
5310       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5311       return RFAILED;
5312    }
5313
5314    macCellGrpCfg->phr_Config = NULLP;
5315    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5316    if(!macCellGrpCfg->phr_Config)
5317    {
5318       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5319       return RFAILED;
5320    }
5321
5322    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5323    {
5324       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5325       return RFAILED;
5326    }
5327
5328    macCellGrpCfg->skipUplinkTxDynamic = false;
5329    macCellGrpCfg->ext1 = NULLP;
5330
5331    return ROK;
5332 }
5333 /*******************************************************************
5334  *
5335  * @brief Frees memeory allocated for SearchSpcToAddModList
5336  *
5337  * @details
5338  *
5339  *    Function : FreeSearchSpcToAddModList
5340  *
5341  *    Functionality: Deallocating memory of SearchSpcToAddModList
5342  *
5343  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5344  *
5345  * @return void
5346  *
5347  4221 * ****************************************************************/
5348 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5349 {
5350    uint8_t idx1=0;
5351    uint8_t idx2=0;
5352    struct  SearchSpace *searchSpc=NULLP;
5353
5354    if(searchSpcList->list.array)
5355    {
5356       if(searchSpcList->list.array[idx2])
5357       {
5358          searchSpc = searchSpcList->list.array[idx2];
5359          if(searchSpc->controlResourceSetId)
5360          {
5361             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5362             {
5363                if(searchSpc->monitoringSymbolsWithinSlot)
5364                {
5365                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5366                   {
5367                      if(searchSpc->nrofCandidates)
5368                      {
5369                         if(searchSpc->searchSpaceType)
5370                         {
5371                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5372                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5373                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5374                                     SearchSpace__searchSpaceType));
5375                         }
5376                         CU_FREE(searchSpc->nrofCandidates,
5377                               sizeof(struct SearchSpace__nrofCandidates));
5378                      }
5379                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5380                            searchSpc->monitoringSymbolsWithinSlot->size);
5381                   }
5382                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5383                         sizeof(BIT_STRING_t));
5384                }
5385                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5386                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5387             }
5388             CU_FREE(searchSpc->controlResourceSetId,
5389                   sizeof(ControlResourceSetId_t));
5390          }
5391       }
5392       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5393       {
5394          CU_FREE(searchSpcList->list.array[idx1],
5395                sizeof(struct SearchSpace));
5396       }
5397       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5398    }
5399 }
5400 /*******************************************************************
5401  *
5402  * @brief Frees memory allocated for PdschTimeDomAllocList
5403  *
5404  * @details
5405  *
5406  *    Function : FreePdschTimeDomAllocList
5407  *
5408  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5409  *
5410  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5411  *
5412  * @return void
5413  *
5414  4221 * ****************************************************************/
5415 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5416 {
5417    uint8_t idx1=0;
5418
5419    if(timeDomAllocList->choice.setup)
5420    {
5421       if(timeDomAllocList->choice.setup->list.array)
5422       {
5423          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5424          {
5425             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5426                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5427          }
5428          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5429                timeDomAllocList->choice.setup->list.size);
5430       }
5431       CU_FREE(timeDomAllocList->choice.setup,\
5432             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5433    }
5434 }
5435 /*******************************************************************
5436  *
5437  * @brief Frees memory allocated for PuschTimeDomAllocList
5438  *
5439  *@details
5440  *
5441  *    Function : FreePuschTimeDomAllocList
5442  *
5443  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5444  *
5445  * @params[in] PUSCH_Config_t *puschCfg
5446  *
5447  * @return void
5448  *
5449  ***********************************************************************/
5450 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5451 {
5452    uint8_t idx1=0;
5453    uint8_t idx2=0;
5454    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5455
5456    if(puschCfg->pusch_TimeDomainAllocationList)
5457    {
5458       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5459       if(timeDomAllocList_t->choice.setup)
5460       {
5461          if(timeDomAllocList_t->choice.setup->list.array)
5462          {
5463             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5464             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5465             {
5466                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5467                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5468             }
5469             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5470                   timeDomAllocList_t->choice.setup->list.size);
5471          }
5472          CU_FREE(timeDomAllocList_t->choice.setup, \
5473                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5474       }
5475       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5476       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5477             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5478    }
5479
5480 }
5481
5482 /*******************************************************************
5483  *
5484  * @brief Frees memory allocated for Dedicated PUCCH config
5485  *
5486  * @details
5487  *
5488  *    Function : FreeBWPUlDedPucchCfg
5489  *
5490  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5491  *
5492  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5493  *
5494  * @return void
5495  *
5496  * ****************************************************************/
5497 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5498 {
5499    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5500    PUCCH_Config_t *pucchCfg = NULLP;
5501    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5502    PUCCH_Resource_t *rsrc = NULLP;
5503
5504    if(ulBwpPucchCfg)
5505    {
5506       if(ulBwpPucchCfg->choice.setup)
5507       {
5508          pucchCfg = ulBwpPucchCfg->choice.setup;
5509
5510          //Free resource set list
5511          if(pucchCfg->resourceSetToAddModList)
5512          {
5513             if(pucchCfg->resourceSetToAddModList->list.array)
5514             {
5515                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5516                {
5517                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5518                   if(rsrcSet->resourceList.list.array)
5519                   {
5520                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5521                      {
5522                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5523                      }
5524                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5525                   }
5526                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5527                }
5528                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5529             }
5530             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5531          }
5532
5533          //Free resource list
5534          if(pucchCfg->resourceToAddModList)
5535          {
5536             if(pucchCfg->resourceToAddModList->list.array)
5537             {
5538                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5539                {
5540                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5541                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5542                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5543                }
5544                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5545             }
5546             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5547          }
5548
5549          //PUCCH Format 1
5550          if(pucchCfg->format1)
5551          {
5552             if(pucchCfg->format1->choice.setup)
5553             {
5554                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5555                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5556             }
5557             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5558          }
5559
5560          //DL DATA TO UL ACK
5561          if(pucchCfg->dl_DataToUL_ACK)
5562          {
5563             if(pucchCfg->dl_DataToUL_ACK->list.array)
5564             {
5565                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5566                {
5567                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5568                }
5569                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5570             }
5571             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5572          }
5573
5574          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5575       }
5576       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5577    }
5578 }
5579
5580 /*******************************************************************
5581  *
5582  * @brief Frees memory allocated for InitialUlBWP
5583  *
5584  * @details
5585  *
5586  *    Function : FreeInitialUlBWP
5587  *
5588  *    Functionality: Deallocating memory of InitialUlBWP
5589  *
5590  * @params[in] BWP_UplinkDedicated_t *ulBwp
5591  *
5592  * @return void
5593  *
5594  * ****************************************************************/
5595 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5596 {
5597    uint8_t  rSetIdx, rsrcIdx;
5598    SRS_Config_t   *srsCfg = NULLP;
5599    PUSCH_Config_t *puschCfg = NULLP;
5600    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5601    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5602    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5603    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5604
5605    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5606
5607    if(ulBwp->pusch_Config)
5608    {
5609       if(ulBwp->pusch_Config->choice.setup)
5610       {
5611          puschCfg=ulBwp->pusch_Config->choice.setup;
5612          if(puschCfg->dataScramblingIdentityPUSCH)
5613          {
5614             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5615             {
5616                FreePuschTimeDomAllocList(puschCfg);
5617                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5618                if(dmrsUlCfg->choice.setup)
5619                {
5620                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5621                   {
5622                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5623                      {
5624                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5625                               sizeof(long));
5626                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5627                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5628                      }
5629                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5630                            sizeof(long));
5631                   }
5632                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5633                }
5634                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5635                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5636             }
5637             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5638          }
5639          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5640       }
5641       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5642
5643       /* Free SRS-Config */
5644       if(ulBwp->srs_Config)
5645       {
5646          if(ulBwp->srs_Config->choice.setup)
5647          {
5648             srsCfg = ulBwp->srs_Config->choice.setup;
5649
5650             /* Free Resource Set to add/mod list */
5651             if(srsCfg->srs_ResourceSetToAddModList)
5652             {
5653                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5654                if(rsrcSetList->list.array)
5655                {
5656                   rSetIdx = 0;
5657
5658                   /* Free SRS resource Id list in this SRS resource set */
5659                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5660                   {
5661                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5662
5663                      if(rsrcIdList->list.array)
5664                      {
5665                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5666                         {
5667                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5668                         }
5669                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5670                      }
5671                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5672                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5673                   }
5674
5675                   /* Free resource type info for this SRS resource set */
5676                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5677                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5678
5679                   /* Free memory for each resource set */
5680                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5681                   {
5682                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5683                   }
5684                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5685                }
5686                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5687                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5688             }
5689
5690             /* Free resource to add/modd list */
5691             if(srsCfg->srs_ResourceToAddModList)
5692             {
5693                resourceList = srsCfg->srs_ResourceToAddModList;
5694                if(resourceList->list.array)
5695                {
5696                   rsrcIdx = 0;
5697                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5698                         sizeof(struct SRS_Resource__transmissionComb__n2));
5699                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5700                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5701
5702                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5703                   {
5704                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5705                   }
5706                   CU_FREE(resourceList->list.array, resourceList->list.size);
5707                }
5708                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5709                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5710             }
5711
5712             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5713          }
5714          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5715       }
5716    }
5717 }
5718 /*******************************************************************
5719  *
5720  * @brief Frees memory allocated for initialUplinkBWP
5721  *
5722  * @details
5723  *
5724  *    Function : FreeinitialUplinkBWP
5725  *
5726  *    Functionality: Deallocating memory of initialUplinkBWP
5727  *
5728  * @params[in] UplinkConfig_t *ulCfg
5729  *
5730  * @return void
5731  *
5732  *
5733  * ****************************************************************/
5734 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5735 {
5736    BWP_UplinkDedicated_t *ulBwp=NULLP;
5737    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5738
5739    if(ulCfg->initialUplinkBWP)
5740    {
5741       ulBwp=ulCfg->initialUplinkBWP;
5742       if(ulCfg->firstActiveUplinkBWP_Id)
5743       {
5744          if(ulCfg->pusch_ServingCellConfig)
5745          {
5746             puschCfg=ulCfg->pusch_ServingCellConfig;
5747             if(puschCfg->choice.setup)
5748             {
5749                if(puschCfg->choice.setup->ext1)
5750                {
5751                   CU_FREE(puschCfg->choice.setup->ext1->\
5752                         processingType2Enabled,sizeof(BOOLEAN_t));
5753                   CU_FREE(puschCfg->choice.setup->ext1->\
5754                         maxMIMO_Layers,sizeof(long));
5755                   CU_FREE(puschCfg->choice.setup->ext1, \
5756                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5757                }
5758                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5759             }
5760             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5761          }
5762          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5763       }
5764       FreeInitialUlBWP(ulBwp);
5765       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5766    }
5767 }
5768 /*******************************************************************
5769  *
5770  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5771  *
5772  * @details
5773  *
5774  *    Function : FreeBWPDlDedPdschCfg
5775  *
5776  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5777  *
5778  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5779  *
5780  * @return void
5781  *
5782  *
5783  * ****************************************************************/
5784 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5785 {
5786    struct PDSCH_Config *pdschCfg=NULLP;
5787    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5788    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5789    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5790
5791    if(dlBwp->pdsch_Config->choice.setup)
5792    {
5793       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5794       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5795       {
5796          if(pdschCfg->pdsch_TimeDomainAllocationList)
5797          {
5798             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5799             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5800             {
5801                prbBndlType=&pdschCfg->prb_BundlingType;
5802                CU_FREE(prbBndlType->choice.staticBundling,\
5803                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5804                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5805             }
5806             FreePdschTimeDomAllocList(timeDomAllocList);
5807             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5808                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5809          }
5810          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5811          if(dmrsDlCfg->choice.setup)
5812          {
5813             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5814                   sizeof(long));
5815             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5816          }
5817          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5818                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5819       }
5820       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5821    }
5822 }
5823 /*******************************************************************
5824  *
5825  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5826  *
5827  * @details
5828  *
5829  *    Function : FreeBWPDlDedPdcchCfg
5830  *
5831  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5832  *
5833  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5834  *
5835  * @return void
5836  *
5837  *
5838  * ****************************************************************/
5839 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5840 {
5841    uint8_t idx1=0;
5842    uint8_t idx2=0;
5843    struct PDCCH_Config *pdcchCfg=NULLP;
5844    struct ControlResourceSet *controlRSet=NULLP;
5845    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5846
5847    if(dlBwp->pdcch_Config->choice.setup)
5848    {
5849       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5850       if(pdcchCfg->controlResourceSetToAddModList)
5851       {
5852          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5853          if(controlRSetList->list.array)
5854          {
5855             controlRSet = controlRSetList->list.array[idx2];
5856             if(controlRSet)
5857             {
5858                if(controlRSet->frequencyDomainResources.buf)
5859                {
5860                   if(controlRSet->pdcch_DMRS_ScramblingID)
5861                   {
5862                      if(pdcchCfg->searchSpacesToAddModList)
5863                      {
5864                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5865                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5866                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5867                      }
5868                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5869                   }
5870                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5871                         controlRSet->frequencyDomainResources.size);
5872                }
5873             }
5874             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5875             {
5876                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5877             }
5878             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5879          }
5880          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5881                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5882       }
5883       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5884    }
5885 }
5886 /*******************************************************************
5887  *
5888  * @brief Builds RLC Config
5889  *
5890  * @details
5891  *
5892  *    Function : BuildRlcConfig
5893  *
5894  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5895  *
5896  * @params[in] RLC_Config *rlcConfig
5897  *
5898  * @return ROK     - success
5899  *         RFAILED - failure
5900  *
5901  * ****************************************************************/
5902 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
5903 {
5904    rlcConfig->present = rlcLcCfgDb.rlcMode;
5905
5906    switch(rlcConfig->present)
5907    {
5908       case RLC_Config_PR_am:
5909          {
5910             rlcConfig->choice.am = NULLP;
5911             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5912             if(!rlcConfig->choice.am)
5913             {
5914                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5915                return RFAILED;
5916             }
5917
5918             /* UL */
5919             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5920             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5921             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5922             {
5923                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5924                return RFAILED;
5925             }
5926             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
5927             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
5928             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
5929             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
5930             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
5931
5932             /* DL */
5933             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5934             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5935             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5936             {
5937                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5938                return RFAILED;
5939             }
5940             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
5941             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
5942             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
5943
5944             break;
5945          }
5946
5947       case RLC_Config_PR_um_Bi_Directional:
5948          {
5949             rlcConfig->choice.um_Bi_Directional = NULLP;
5950             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
5951             if(!rlcConfig->choice.um_Bi_Directional)
5952             {
5953                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5954                return RFAILED;
5955             }
5956
5957             /* UL */
5958             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
5959             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5960             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
5961             {
5962                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5963                return RFAILED;
5964             }
5965             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
5966
5967             /* DL */
5968             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
5969             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5970             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
5971             {
5972                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5973                return RFAILED;
5974             }
5975             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
5976             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
5977             break;
5978          }
5979    }
5980    return ROK;
5981 }
5982
5983 /*******************************************************************
5984  *
5985  * @brief Builds MAC LC Config
5986  *
5987  * @details
5988  *
5989  *    Function : BuildMacLCConfig
5990  *
5991  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5992  *
5993  * @params[in] struct LogicalChannelConfig macLcConfig
5994  *
5995  * @return ROK     - success
5996  *         RFAILED - failure
5997  *
5998  * ****************************************************************/
5999 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6000 {
6001
6002    macLcConfig->ul_SpecificParameters = NULLP;
6003    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6004    if(!macLcConfig->ul_SpecificParameters)
6005    {
6006       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6007       return RFAILED;
6008    }
6009
6010    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6011    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6012    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6013    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6014    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6015    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6016    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6017
6018    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6019    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6020    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6021    {
6022       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6023       return RFAILED;
6024    }
6025    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6026
6027    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6028    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6029    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6030    {
6031       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6032       return RFAILED;
6033    }
6034    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6035
6036    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6037    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6038    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6039
6040    return ROK;
6041 }
6042 /*******************************************************************
6043  *
6044  * @brief Builds RLC Bearer to Add/Mod list
6045  *
6046  * @details
6047  *
6048  *    Function :BuildRlcBearerToAddModList
6049  *
6050  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6051  *
6052  * @params[in] rlc_BearerToAddModList
6053  *
6054  * @return ROK     - success
6055  *         RFAILED - failure
6056  *
6057  * ****************************************************************/
6058 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6059 {
6060    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6061
6062    if(updateAllRbCfg)
6063       elementCnt = ueCb->numSrb + ueCb->numDrb;
6064    else
6065    {
6066       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6067       {
6068          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6069             elementCnt++;
6070       }
6071
6072       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6073       {
6074          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6075             elementCnt++;
6076       }
6077    }
6078
6079    if(!elementCnt)
6080    {
6081       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6082       return ROK;
6083    }
6084    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6085    if(!rlcBearerList)
6086    {
6087       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6088       return RFAILED;
6089    }
6090    rlcBearerList->list.count = elementCnt;
6091    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6092
6093    rlcBearerList->list.array = NULLP;
6094    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6095    if(!rlcBearerList->list.array)
6096    {
6097       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6098       return RFAILED;
6099    }
6100
6101    for(idx=0; idx<rlcBearerList->list.count; idx++)
6102    {
6103       rlcBearerList->list.array[idx] = NULLP;
6104       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6105       if(!rlcBearerList->list.array[idx])
6106       {
6107          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6108          return RFAILED;
6109       }
6110    }
6111
6112    idx = 0;
6113
6114    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6115    {
6116       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6117          continue;
6118
6119       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6120
6121       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6122       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6123       {
6124          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6125          return RFAILED;
6126       }
6127
6128       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6129       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6130
6131       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6132       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6133       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6134       if(!rlcBearerList->list.array[idx]->rlc_Config)
6135       {
6136          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6137          return RFAILED;
6138       }
6139
6140       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6141       {
6142          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6143          return RFAILED;
6144       }
6145
6146       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6147       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6148       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6149       {
6150          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6151          return RFAILED;
6152       }
6153
6154       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6155       {
6156          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6157          return RFAILED;
6158       }
6159       idx++;
6160    }
6161
6162    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6163    {
6164       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6165          continue;
6166
6167       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6168
6169       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6170       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6171       {
6172          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6173          return RFAILED;
6174       }
6175
6176       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6177       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6178
6179       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6180       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6181       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6182       if(!rlcBearerList->list.array[idx]->rlc_Config)
6183       {
6184          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6185          return RFAILED;
6186       }
6187
6188       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6189       {
6190          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6191          return RFAILED;
6192       }
6193
6194       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6195       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6196       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6197       {
6198          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6199          return RFAILED;
6200       }
6201
6202       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6203       {
6204          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6205          return RFAILED;
6206       }
6207       idx++;
6208    }
6209    return ROK;
6210 }
6211
6212 /*******************************************************************
6213  *
6214  * @brief Free memory allocated for CellGroupConfig
6215  *
6216  * @details
6217  *
6218  *    Function : FreeMemCellGrpCfg
6219  *
6220  *    Functionality: Deallocating memory of CellGroupConfig
6221  *
6222  * @params[in] pointer to CellGroupConfigRrc_t
6223  *
6224  * @return ROK     - success
6225  *         RFAILED - failure
6226  *
6227  ******************************************************************/
6228 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6229 {
6230    uint8_t idx=0;
6231    SpCellConfig_t *spCellCfg=NULLP;
6232    ServingCellConfig_t *srvCellCfg=NULLP;
6233    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6234    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6235    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6236    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6237    struct RLC_Config *rlcConfig=NULLP;
6238    struct LogicalChannelConfig *macLcConfig=NULLP;
6239    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6240    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6241    struct TAG_Config *tagConfig=NULLP;
6242    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6243    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6244    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6245
6246    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6247    if(rlcBearerList)
6248    {
6249       if(rlcBearerList->list.array)
6250       {
6251          for(idx=0; idx<rlcBearerList->list.count; idx++)
6252          {
6253             if(rlcBearerList->list.array[idx])
6254             {
6255                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6256                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6257                if(rlcConfig)
6258                {
6259                   if(rlcConfig->choice.am)
6260                   {
6261                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6262                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6263                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6264                   }
6265                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6266                }
6267                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6268                if(macLcConfig)
6269                {
6270                   if(macLcConfig->ul_SpecificParameters)
6271                   {
6272                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6273                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6274                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6275                   }
6276                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6277                }
6278                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6279             }
6280          }
6281          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6282       }
6283       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6284    }
6285
6286    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6287    if(macCellGrpCfg)
6288    {
6289       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6290       if(schedulingRequestConfig)
6291       {
6292          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6293          if(schReqList)
6294          {
6295             if(schReqList->list.array)
6296             {
6297                for(idx=0;idx<schReqList->list.count; idx++)
6298                {
6299                   if(schReqList->list.array[idx])
6300                   {
6301                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6302                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6303                   }
6304                }
6305                CU_FREE(schReqList->list.array, schReqList->list.size);
6306             }
6307             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6308                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6309             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6310       }
6311       if(macCellGrpCfg->bsr_Config)
6312       {
6313          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6314       }
6315       tagConfig = macCellGrpCfg->tag_Config;
6316       if(tagConfig)
6317       {
6318          tagList = tagConfig->tag_ToAddModList;
6319          if(tagList)
6320          {
6321             if(tagList->list.array)
6322             {
6323                for(idx=0; idx<tagList->list.count; idx++)
6324                {
6325                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6326                }
6327                CU_FREE(tagList->list.array, tagList->list.size);
6328             }
6329             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6330          }
6331          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6332       }
6333
6334       phrConfig = macCellGrpCfg->phr_Config;
6335       if(phrConfig)
6336       {
6337          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6338          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6339       }
6340
6341       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6342    }
6343
6344    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6345    if(phyCellGrpCfg)
6346    {
6347       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6348       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6349    }
6350
6351    spCellCfg = cellGrpCfg->spCellConfig;
6352    if(spCellCfg)
6353    {
6354       if(spCellCfg->servCellIndex)
6355       {
6356          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6357          {
6358             if(spCellCfg->spCellConfigDedicated)
6359             {
6360                srvCellCfg = spCellCfg->spCellConfigDedicated;
6361                if(srvCellCfg->initialDownlinkBWP)
6362                {
6363                   dlBwp = srvCellCfg->initialDownlinkBWP;
6364                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6365                   {
6366                      if(srvCellCfg->defaultDownlinkBWP_Id)
6367                      {
6368                         if(srvCellCfg->uplinkConfig)
6369                         {
6370                            if(srvCellCfg->pdsch_ServingCellConfig)
6371                            {
6372                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6373                               if(pdschCfg->choice.setup)
6374                               {
6375                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6376                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6377                               }
6378                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6379                                        ServingCellConfig__pdsch_ServingCellConfig));
6380                            }
6381                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6382                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6383                         }
6384                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6385                      }
6386                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6387                   }
6388                   if(dlBwp->pdcch_Config)
6389                   {
6390                      if(dlBwp->pdsch_Config)
6391                      {
6392                         FreeBWPDlDedPdschCfg(dlBwp);
6393                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6394                      }
6395                      FreeBWPDlDedPdcchCfg(dlBwp);
6396                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6397                   }
6398                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6399                }
6400                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6401             }
6402             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6403          }
6404          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6405       }
6406       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6407    }
6408    return ROK;
6409 }
6410
6411 /*******************************************************************
6412  *
6413  * @brief Fills CellGroupConfig
6414  *
6415  * @details
6416  *
6417  *    Function : fillCellGrpCfg
6418  *
6419  *    Functionality: Fills CellGroupConfig
6420  *
6421  * @params[in] pointer to CellGroupConfigRrc_t
6422  *
6423  * @return ROK     - success
6424  *         RFAILED - failure
6425  *
6426  ******************************************************************/
6427
6428 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6429 {
6430    uint8_t               ret = RFAILED;
6431    CellGroupConfigRrc_t  cellGrpCfg;
6432    asn_enc_rval_t        encRetVal;
6433
6434    while(true)
6435    {
6436       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6437
6438       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6439
6440       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6441       {
6442          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6443          break;
6444       }
6445
6446       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6447       cellGrpCfg.mac_CellGroupConfig = NULLP;
6448       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6449       if(!cellGrpCfg.mac_CellGroupConfig)
6450       {
6451          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6452          break;
6453       }
6454       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6455       {
6456          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6457          break;
6458       }
6459
6460       cellGrpCfg.physicalCellGroupConfig = NULLP;
6461       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6462       if(!cellGrpCfg.physicalCellGroupConfig)
6463       {
6464          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6465          break;
6466       }
6467       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6468       {
6469          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6470          break;
6471       }
6472
6473       cellGrpCfg.spCellConfig = NULLP;
6474       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6475       if(!cellGrpCfg.spCellConfig)
6476       {
6477          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6478          break;
6479       }
6480       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6481       {
6482          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6483          break;
6484       }
6485
6486       cellGrpCfg.sCellToAddModList = NULLP;
6487       cellGrpCfg.sCellToReleaseList = NULLP;
6488       cellGrpCfg.ext1 = NULLP;
6489
6490       /* encode cellGrpCfg into duToCuRrcContainer */
6491       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6492       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6493       encBufSize = 0;
6494       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6495       /* Encode results */
6496       if(encRetVal.encoded == ENCODE_FAIL)
6497       {
6498          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6499                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6500          break;
6501       }
6502       else
6503       {
6504          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6505          for(int i=0; i< encBufSize; i++)
6506          {
6507             DU_LOG("%x",encBuf[i]);
6508          }
6509       }
6510
6511       cellGrp->size = encBufSize;
6512       CU_ALLOC(cellGrp->buf, cellGrp->size);
6513       if(!cellGrp->buf)
6514       {
6515          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6516          break;
6517       }
6518       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6519       ret = ROK;
6520       break;
6521    }
6522    FreeMemCellGrpCfg(&cellGrpCfg);
6523    return ret;
6524 }
6525
6526 /*******************************************************************
6527  *
6528  * @brief Free UE Capability RAT container
6529  *
6530  * @details
6531  *
6532  *    Function : freeUeCapRatCont
6533  *
6534  *    Functionality:
6535  *       Free UE Capability RAT conatiner
6536  *
6537  * @params[in]
6538  * @return ROK     - success
6539  *         RFAILED - failure
6540  *
6541  * ****************************************************************/
6542 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6543 {
6544    uint8_t idx;
6545    FeatureSets_t *featureSets;
6546
6547    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6548    {
6549       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6550       {
6551          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6552             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6553       }
6554       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6555    }
6556
6557    if(ueNrCap->featureSets)
6558    {
6559       featureSets = ueNrCap->featureSets;
6560       if(featureSets->featureSetsDownlinkPerCC)
6561       {
6562          if(featureSets->featureSetsDownlinkPerCC->list.array)
6563          {
6564             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6565             {
6566                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6567                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6568                         sizeof(ModulationOrder_t));
6569                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6570             }
6571             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6572          }
6573          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6574       }
6575
6576       if(featureSets->featureSetsUplinkPerCC)
6577       {
6578          if(featureSets->featureSetsUplinkPerCC->list.array)
6579          {
6580             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6581             {
6582                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6583                {
6584                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6585                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6586                          sizeof(ModulationOrder_t));
6587                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6588                }
6589             }
6590             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6591          }
6592          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6593       }
6594       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6595    }
6596 }
6597
6598 /*******************************************************************
6599  *
6600  * @brief Free UE capability RAT container list
6601  *
6602  * @details
6603  *
6604  *    Function : freeUeCapRatContList
6605  *
6606  *    Functionality: Free UE capability RAT container list
6607  *
6608  * @params[in]
6609  * @return ROK     - success
6610  *         RFAILED - failure
6611  *
6612  * ****************************************************************/
6613 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6614 {
6615    uint8_t idx;
6616    if(ueCapablityList->list.array)
6617    {
6618       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6619       {
6620          if(ueCapablityList->list.array[idx])
6621             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6622       }
6623       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6624    }
6625 }
6626
6627 /*******************************************************************
6628  *
6629  * @brief Free Handover preparation information
6630  *
6631  * @details
6632  *
6633  *    Function : freeHOPreparationInfo
6634  *
6635  *    Functionality: Free Handover preparation information
6636  *
6637  * @params[in]
6638  * @return ROK     - success
6639  *         RFAILED - failure
6640  *
6641  * ****************************************************************/
6642 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6643 {
6644    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6645
6646    if(hoPrep->criticalExtensions.choice.c1)
6647    {
6648       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6649       {
6650          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6651          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6652          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6653                sizeof(HandoverPreparationInformationRrc_IEs_t));
6654       }
6655       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6656    }
6657 }
6658
6659 /*******************************************************************
6660  *
6661  * @brief Fill feature sets
6662  *
6663  * @details
6664  *
6665  *    Function : fillFeatureSets
6666  *
6667  *    Functionality: Fill feature sets
6668  *
6669  * @params[in]
6670  * @return ROK     - success
6671  *         RFAILED - failure
6672  *
6673  * ****************************************************************/
6674 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6675 {
6676    uint8_t idx, elementCnt;
6677
6678    featureSets->featureSetsDownlink = NULLP;
6679    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6680    if(!featureSets->featureSetsDownlinkPerCC)
6681    {
6682       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6683       return RFAILED;
6684    }
6685
6686    elementCnt = 1;
6687    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6688    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6689    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6690    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6691    {
6692       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6693       return RFAILED;
6694    }
6695
6696    for(idx = 0; idx < elementCnt; idx++)
6697    {
6698       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6699       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6700       {
6701          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6702          return RFAILED;
6703       }
6704    }
6705
6706    idx = 0;
6707    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6708    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6709    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6710    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6711    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6712
6713    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6714    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6715    {
6716       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6717       return RFAILED;
6718    }
6719    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6720
6721    featureSets->featureSetsUplink = NULLP;
6722    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6723    if(!featureSets->featureSetsUplinkPerCC)
6724    {
6725       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6726       return RFAILED;
6727    }
6728
6729    elementCnt = 1;
6730    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6731    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6732    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6733    if(!featureSets->featureSetsUplinkPerCC->list.array)
6734    {
6735       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6736       return RFAILED;
6737    }
6738
6739    for(idx = 0; idx < elementCnt; idx++)
6740    {
6741       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6742       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6743       {
6744          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6745          return RFAILED;
6746       }
6747    }
6748
6749    idx = 0;
6750    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6751    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6752    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6753    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6754    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6755    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6756
6757    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6758    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6759    {
6760       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6761       return RFAILED;
6762    }
6763    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6764
6765    return ROK;
6766 }
6767
6768 /*******************************************************************
6769  *
6770  * @brief Fill UE capability RAT container
6771  *
6772  * @details
6773  *
6774  *    Function : fillUeCapRatCont
6775  *
6776  *    Functionality: Fill UE capability RAT container
6777  *
6778  * @params[in] UE Capability RAT container buffer
6779  * @return ROK     - success
6780  *         RFAILED - failure
6781  *
6782  * ****************************************************************/
6783 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6784 {
6785    uint8_t             ret = ROK;
6786    uint8_t             idx, elementCnt;
6787    asn_enc_rval_t      encRetVal;
6788    UE_NR_Capability_t  ueNrCap;
6789
6790    while(true)
6791    {
6792       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6793
6794       /* Filling PDCP parameters */
6795       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6796       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6797       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6798       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6799       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6800       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6801       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6802       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6803       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6804       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6805       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6806       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6807       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6808       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6809       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6810       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6811       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6812
6813       ueNrCap.rlc_Parameters = NULLP;
6814       ueNrCap.mac_Parameters = NULLP;
6815
6816       /* Filling PHY parameters */
6817       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6818       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6819       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6820       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6821       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6822
6823       /* Filling RF parameters */
6824       elementCnt = 1;
6825       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6826       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6827       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6828       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6829       {
6830          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6831          ret = RFAILED;
6832          break;
6833       }
6834
6835       for(idx = 0; idx < elementCnt; idx++)
6836       {
6837          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6838          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6839          {
6840             ret = RFAILED;
6841             break;
6842          }
6843       }
6844       if(ret == RFAILED)
6845          break;
6846
6847       idx = 0;
6848       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6849       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6850       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6851
6852       ueNrCap.measAndMobParameters = NULLP;
6853       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6854       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6855       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6856       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6857       ueNrCap.featureSets = NULLP;
6858
6859       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6860       if(!ueNrCap.featureSets)
6861       {
6862          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6863          ret = RFAILED;
6864          break;
6865       }
6866
6867       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6868       {
6869          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6870          ret = RFAILED;
6871          break;
6872       }
6873
6874       ueNrCap.featureSetCombinations = NULLP;
6875       ueNrCap.lateNonCriticalExtension = NULLP;
6876       ueNrCap.nonCriticalExtension = NULLP;
6877
6878       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6879       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6880       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6881       encBufSize = 0;
6882       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6883
6884       /* Encode results */
6885       if(encRetVal.encoded == ENCODE_FAIL)
6886       {
6887          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6888             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6889          break;
6890       }
6891       else
6892       {
6893          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6894          for(int i=0; i< encBufSize; i++)
6895          {
6896             DU_LOG("%x",encBuf[i]);
6897          }
6898       }
6899
6900       ueCapRatContBuf->size = encBufSize;
6901       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6902       if(!ueCapRatContBuf->buf)
6903       {
6904          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6905          break;
6906       }
6907       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6908       ret = ROK;
6909       break;
6910    }
6911    freeUeCapRatCont(&ueNrCap);
6912    return ROK;
6913 }
6914
6915 /*******************************************************************
6916  *
6917  * @brief Fill UE Capability RAT container list
6918  *
6919  * @details
6920  *
6921  *    Function : fillUeCapRatContList
6922  *
6923  *    Functionality: Fill UE Capability RAT container list
6924
6925  *
6926  * @params[in] UE capability RAT container list
6927  * @return ROK     - success
6928  *         RFAILED - failure
6929  *
6930  * ****************************************************************/
6931 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
6932 {
6933     uint8_t          ret = RFAILED;
6934     uint8_t          idx, elementCnt;
6935
6936     while(true)
6937     {
6938        elementCnt = 1;
6939        ueCapablityList->list.count = elementCnt;
6940        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6941
6942        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
6943        if(!ueCapablityList->list.array)
6944        {
6945           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6946           ret = RFAILED;
6947           break;
6948        }
6949
6950        for(idx=0; idx<elementCnt; idx++)
6951        {
6952           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6953           if(ueCapablityList->list.array[idx] == NULLP)
6954           {
6955              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6956              ret = RFAILED;
6957              break;
6958           }
6959        }
6960        idx = 0;
6961        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
6962        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
6963        {
6964           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
6965           ret = RFAILED;
6966           break;
6967        }
6968
6969        ret = ROK;
6970        break;
6971     }
6972     return ret;
6973 }
6974
6975 /*******************************************************************
6976  *
6977  * @brief Fill UE Capability RAT container list octet string
6978  *
6979  * @details
6980  *
6981  *    Function : fillUeCapRatContListBuf
6982  *
6983  *    Functionality: Fill UE Capability RAT container list octet string
6984
6985  *
6986  * @params[in] UE capability RAT container list buffer
6987  * @return ROK     - success
6988  *         RFAILED - failure
6989  *
6990  * ****************************************************************/
6991 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6992 {
6993    uint8_t          ret = RFAILED;
6994    asn_enc_rval_t   encRetVal;
6995    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
6996
6997    while(true)
6998    {
6999       ret = fillUeCapRatContList(&ueCapablityList);
7000       if(ret != ROK)
7001       {
7002          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7003          break;
7004       }
7005
7006       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7007       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7008       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7009       encBufSize = 0;
7010       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7011             &ueCapablityList, PrepFinalEncBuf, encBuf);
7012
7013       /* Encode results */
7014       if(encRetVal.encoded == ENCODE_FAIL)
7015       {
7016          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7017                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7018          break;
7019       }
7020       else
7021       {
7022          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7023          for(int i=0; i< encBufSize; i++)
7024          {
7025             DU_LOG("%x",encBuf[i]);
7026          }
7027       }
7028
7029       ueCapablityListBuf->size = encBufSize;
7030       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7031       if(!ueCapablityListBuf->buf)
7032       {
7033          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7034          break;
7035       }
7036       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7037       ret = ROK;
7038       break;
7039    }
7040    freeUeCapRatContList(&ueCapablityList);
7041    return ret;
7042 }
7043
7044 /*******************************************************************
7045  *
7046  * @brief Free Measurement Timing Configuration
7047  *
7048  * @details
7049  *
7050  *    Function : freeMeasuementTimingConfig
7051  *
7052  *    Functionality: Free Measurement Timing Configuration
7053  *
7054  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7055  * @return void
7056  *
7057  * ****************************************************************/
7058 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7059 {
7060    uint8_t measCfgIdx;
7061    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7062    MeasTiming_t *measTiming = NULLP;
7063
7064    if(measTimingConfig.criticalExtensions.choice.c1)
7065    {
7066       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7067       {
7068          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7069          if(measTimingCfg->measTiming)
7070          {
7071             if(measTimingCfg->measTiming->list.array)
7072             {
7073                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7074                {
7075                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7076                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7077                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7078                }
7079                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7080             }
7081             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7082          }
7083          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7084       }
7085       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7086    }
7087 }
7088
7089 /*******************************************************************
7090  *
7091  * @brief Fill Measurement Timing Configuration
7092  *
7093  * @details
7094  *
7095  *    Function : fillMeasTimingCfg
7096  *
7097  *    Functionality: Fill Measurement Timing Configuration
7098  *
7099  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7100  * @return ROK     - success
7101  *         RFAILED - failure
7102  *
7103  * ****************************************************************/
7104 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7105 {
7106    uint8_t elementCnt = 0;
7107    uint8_t measCfgIdx = 0;
7108    MeasTiming_t *measTiming;
7109    SSB_MTC_t *smtc;
7110
7111    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7112    if(!measTimingCfg->measTiming)
7113    {
7114       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7115       return RFAILED;
7116    }
7117
7118    elementCnt = 1;
7119    measTimingCfg->measTiming->list.count = elementCnt;
7120    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7121    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7122    if(!measTimingCfg->measTiming->list.array)
7123    {
7124       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7125       return RFAILED;
7126    }
7127
7128    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7129    {
7130       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7131       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7132       {
7133          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7134          return RFAILED;
7135       }
7136    }
7137
7138    measCfgIdx = 0;
7139    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7140    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7141    if(!measTiming->frequencyAndTiming)
7142    {
7143       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7144       return RFAILED;
7145    }
7146
7147    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7148    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7149
7150    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7151    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7152    smtc->periodicityAndOffset.choice.sf20 = 0;
7153    smtc->duration = SSB_MTC__duration_sf1;
7154    return ROK;
7155 }
7156
7157 /*******************************************************************
7158  *
7159  * @brief Fill Measurement Timing Configuration Octet string
7160  *
7161  * @details
7162  *
7163  *    Function : fillMeasConfigBuf
7164  *
7165  *    Functionality: Fill Measurement Timing Configuration Octet string
7166
7167  *
7168  * @params[in] MeasConfig_t *measConfgBuf
7169  * @return ROK     - success
7170  *         RFAILED - failure
7171  *
7172  * ****************************************************************/
7173 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7174 {
7175    uint8_t          ret = RFAILED;
7176    asn_enc_rval_t   encRetVal;
7177    MeasurementTimingConfigurationRrc_t measTimingConfig;
7178
7179    while(true)
7180    {
7181       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7182       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7183       if(!measTimingConfig.criticalExtensions.choice.c1)
7184       {
7185          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7186          return RFAILED;
7187       }
7188       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7189
7190       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7191       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7192       {
7193          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7194          return RFAILED;
7195       }
7196
7197       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7198       if(ret != ROK)
7199       {
7200          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7201          break;
7202       }
7203
7204       /* Encode measurement timing configuration into octet string */
7205       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7206       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7207       encBufSize = 0;
7208       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7209
7210       /* Encode results */
7211       if(encRetVal.encoded == ENCODE_FAIL)
7212       {
7213          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7214                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7215          break;
7216       }
7217       else
7218       {
7219          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7220          for(int i=0; i< encBufSize; i++)
7221          {
7222             DU_LOG("%x",encBuf[i]);
7223          }
7224       }
7225
7226       measTimingConfigBuf->size = encBufSize;
7227       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7228       if(!measTimingConfigBuf->buf)
7229       {
7230          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7231          break;
7232       }
7233       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7234       ret = ROK;
7235       break;
7236    }
7237    freeMeasuementTimingConfig(measTimingConfig);
7238    return ret;
7239 }
7240
7241 /******************************************************************
7242  *
7243  * @brief Free RRC reconfiguration non-critical extension
7244  *
7245  * @details
7246  *
7247  *    Function : freeRrcReconfigNonCriticalExt
7248  *
7249  *    Functionality: Free RRC reconfiguration non-critical extension
7250  *
7251  * @params[in] RRC reconfiguration IE
7252  * @return void
7253  *
7254  * ****************************************************************/
7255 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7256 {
7257    if(rrcRecfg->masterCellGroup)
7258    {
7259       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7260    }
7261 }
7262
7263 /******************************************************************
7264  *
7265  * @brief Free measurement object addmod list
7266  *
7267  * @details
7268  *
7269  *    Function : freeMeasObjToAddModList
7270  *
7271  *    Functionality: Free measurement object add mod list
7272  *
7273  * @params[in] Measurement object add/mod list
7274  * @return void
7275  *
7276  * ****************************************************************/
7277 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7278 {
7279    uint8_t objIdx;
7280    MeasObjectNR_t *measObject;
7281
7282    if(measObjList->list.array)
7283    {
7284       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7285       {
7286          if(measObjList->list.array[objIdx])
7287          {
7288             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7289             {
7290                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7291                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7292                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7293                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7294                if(measObject->absThreshSS_BlocksConsolidation)
7295                {
7296                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7297                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7298                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7299                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7300                }
7301                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7302                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7303                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7304                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7305                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7306             }
7307             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7308          }
7309       }
7310       CU_FREE(measObjList->list.array, measObjList->list.size);
7311    }
7312 }
7313
7314 /******************************************************************
7315  *
7316  * @brief Free report config add mod list
7317  *
7318  * @details
7319  *
7320  *    Function : freeReportCfgToAddModList
7321  *
7322  *    Functionality: Free report config add mod list
7323  *
7324  * @params[in] Report config list
7325  * @return void
7326  *
7327  * ****************************************************************/
7328 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7329 {
7330    uint8_t reportCfgIdx;
7331    ReportConfigToAddMod_t *reportCfg;
7332    ReportConfigNR_t *reportCfgNr;
7333    EventTriggerConfig_t *eventTriggCfg;
7334
7335    if(reportCfgList->list.array)
7336    {
7337       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7338       {
7339          if(reportCfgList->list.array[reportCfgIdx])
7340          {
7341             reportCfg = reportCfgList->list.array[reportCfgIdx];
7342             if(reportCfg->reportConfig.choice.reportConfigNR)
7343             {
7344                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7345                if(reportCfgNr->reportType.choice.eventTriggered)
7346                {
7347                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7348                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7349                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7350                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7351                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7352                }
7353             }
7354          }
7355          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7356       }
7357       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7358    }
7359 }
7360
7361 /******************************************************************
7362  *
7363  * @brief Free measurement id to add mod list
7364  *
7365  * @details
7366  *
7367  *    Function : freeMeasIdToAddModList
7368  *
7369  *    Functionality: Free measurement id to add mod list
7370  *
7371  * @params[in] Measurement id to add mod list
7372  * @return void
7373  *
7374  * ****************************************************************/
7375 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7376 {
7377    uint8_t measIdIdx;
7378    if(measIdList->list.array)
7379    {
7380       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7381       {
7382          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7383       }
7384       CU_FREE(measIdList->list.array, measIdList->list.size);
7385    }
7386 }
7387
7388 /*******************************************************************
7389  *
7390  * @brief Free quantity config
7391  *
7392  * @details
7393  *
7394  *    Function : freeQunatityConfig
7395  *
7396  *    Functionality: Free quantity config
7397  *
7398  * @params[in] Quantity Config
7399  * @return void
7400  *
7401  * ****************************************************************/
7402 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7403 {
7404    uint8_t quanCfgIdx;
7405    QuantityConfigNR_t *quantityCfgNr;
7406
7407    if(quantityCfg->quantityConfigNR_List)
7408    {
7409       if(quantityCfg->quantityConfigNR_List->list.array)
7410       {
7411          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7412          {
7413             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7414             {
7415                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7416                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7417                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7418                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7419                if(quantityCfgNr->quantityConfigRS_Index)
7420                {
7421                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7422                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7423                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7424                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7425                }
7426                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7427             }
7428          }
7429          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7430       }
7431       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7432    }
7433 }
7434
7435 /******************************************************************
7436  *
7437  * @brief Free measurement Config
7438  *
7439  * @details
7440  *
7441  *    Function : freeMeasConfig
7442  *
7443  *    Functionality: Free measurement config
7444  *
7445  * @params[in] Measurement config
7446  * @return void
7447  *
7448  * ****************************************************************/
7449 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7450 {
7451    if(measConfig->measObjectToAddModList)
7452    {
7453       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7454       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7455    }
7456    if(measConfig->reportConfigToAddModList)
7457    {
7458       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7459       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7460    }
7461    if(measConfig->measIdToAddModList)
7462    {
7463       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7464       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7465    }
7466    if(measConfig->s_MeasureConfig)
7467    {
7468       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7469    }
7470    if(measConfig->quantityConfig)
7471    {
7472       freeQuantityConfig(measConfig->quantityConfig);
7473       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7474    }
7475 }
7476 /******************************************************************
7477  *
7478  * @brief Free DRB to AddMod List
7479  *
7480  * @details
7481  *
7482  *    Function : freeDrbToAddModList
7483  *
7484  *    Functionality: Free SRB to AddMod List
7485  *
7486  * @params[in] SBR to add/mod list
7487  * @return void
7488  *
7489  * ****************************************************************/
7490 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7491 {
7492    uint8_t drbIdx;
7493    if(drbToAddList->list.array)
7494    {
7495       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7496       {
7497          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7498          {
7499             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7500             {
7501                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7502                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7503                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7504                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7505             }
7506             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7507             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7508          }
7509          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7510       }
7511       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7512    }
7513 }
7514
7515 /******************************************************************
7516  *
7517  * @brief Free SRB to AddMod List
7518  *
7519  * @details
7520  *
7521  *    Function : freeSrbToAddModList
7522  *
7523  *    Functionality: Free SRB to AddMod List
7524  *
7525  * @params[in] SBR to add/mod list
7526  * @return void
7527  *
7528  * ****************************************************************/
7529 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7530 {
7531    uint8_t srbIdx;
7532    if(srbToAddList->list.array)
7533    {
7534       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7535       {
7536          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7537          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7538          {
7539             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7540             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7541          }
7542
7543          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7544       }
7545       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7546    }
7547 }
7548
7549 /******************************************************************
7550  *
7551  * @brief Free Radio Bearer Config
7552  *
7553  * @details
7554  *
7555  *    Function : freeRadioBearerConfig
7556  *
7557  *    Functionality: Free Radio Bearer config
7558  *
7559  * @params[in] Radio bearer config
7560  * @return void
7561  *
7562  * ****************************************************************/
7563 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7564 {
7565    if(radioBearerConfig->srb_ToAddModList)
7566    {
7567       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7568       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7569    }
7570    if(radioBearerConfig->drb_ToAddModList)
7571    {
7572       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7573       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7574    }
7575 }
7576
7577 /******************************************************************
7578  *
7579  * @brief Free reconfiguration message
7580  *
7581  * @details
7582  *
7583  *    Function : freeRrcReconfig
7584  *
7585  *    Functionality: Free reconfiguration message
7586  *
7587  * @params[in] RRC Reconfiguration message
7588  * @return void
7589  *
7590  * ****************************************************************/
7591 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7592 {
7593    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7594    {
7595       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7596       {
7597          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7598          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7599       }
7600       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7601       {
7602          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7603          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7604       }
7605       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7606       {
7607          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7608          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7609       }
7610       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7611    }
7612 }
7613
7614 /******************************************************************
7615  *
7616  * @brief Fill SRB To Add Mod list
7617  *
7618  * @details
7619  *
7620  *    Function : fillSrbToAddModList
7621  *
7622  *    Functionality: fill SRB to Add Mod list
7623  *
7624  * @params[in] UE control block
7625  *             SRB to Add/Mod list
7626  * @return ROK     - success
7627  *         RFAILED - failure
7628  *
7629  * ****************************************************************/
7630 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7631 {
7632    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7633
7634    if(updateAllRbCfg)
7635       elementCnt = ueCb->numSrb;
7636    else
7637    {
7638       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7639       {
7640          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7641             elementCnt++;
7642       }
7643    }
7644
7645    if(!elementCnt)
7646    {
7647       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7648       return ROK;
7649    }
7650
7651    srbToAddList->list.count = elementCnt;
7652    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7653
7654    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7655    if(!srbToAddList->list.array)
7656    {
7657       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7658       return RFAILED;
7659    }
7660
7661    srbIdx = 0;
7662    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7663    {
7664       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7665          continue;
7666
7667       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7668       if(!srbToAddList->list.array[srbIdx])
7669       {
7670          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7671          return RFAILED;
7672       }
7673
7674       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7675
7676       /* Reestablish PDCP */
7677       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7678       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7679       {
7680          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7681          return RFAILED;
7682       }
7683       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7684
7685       /* PDCP configuration */
7686       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7687       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7688       {
7689          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7690          return RFAILED;
7691       }
7692
7693       /* Reordering timer */
7694       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7695       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7696       {
7697          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7698          return RFAILED;
7699       }
7700       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7701
7702       srbIdx++;
7703    }
7704    return ROK;
7705 }
7706
7707 /******************************************************************
7708  *
7709  * @biief Fill DRBeTo Add Mod list
7710  *
7711  * @details
7712  *
7713  *    Function : fillDrbToAddModList
7714  *
7715  *    Functionality: fill DRB to Add Mod list
7716  *
7717  * @params[in] UE control block
7718  *             DRB to Add/Mod list
7719  * @return ROK     - success
7720  *         RFAILED - failure
7721  *
7722  * ****************************************************************/
7723 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7724 {
7725    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7726
7727    if(updateAllRbCfg)
7728       elementCnt = ueCb->numDrb;
7729    else
7730    {
7731       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7732       {
7733          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7734             elementCnt++;
7735       }
7736    }
7737
7738    if(!elementCnt)
7739    {
7740       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7741       return ROK;
7742    }
7743
7744
7745    drbToAddList->list.count = elementCnt;
7746    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7747
7748    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7749    if(!drbToAddList->list.array)
7750    {
7751       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7752       return RFAILED;
7753    }
7754
7755    drbIdx = 0;
7756    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7757    {
7758       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7759          continue;
7760
7761       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7762       if(!drbToAddList->list.array[drbIdx])
7763       {
7764          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7765          return RFAILED;
7766       }
7767
7768       /* DRB Id */
7769       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7770
7771       /* PDCP Config */
7772       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7773       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7774       {
7775          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7776          return RFAILED;
7777       }
7778
7779       /* PDCP Config -> DRB */
7780       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7781       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7782       {
7783          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7784          return RFAILED;
7785       }
7786
7787       /* DRB -> Discard Timer */
7788       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7789       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
7790       {
7791          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
7792          return RFAILED;
7793       }
7794       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
7795
7796       /* UL PDCP SN length */
7797       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7798       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
7799       {
7800          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
7801          return RFAILED;
7802       }
7803       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
7804
7805       /* DL PDCP SN length */
7806       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7807       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
7808       {
7809          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
7810          return RFAILED;
7811       }
7812       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
7813
7814       /* Header Compression */
7815       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
7816        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
7817
7818       /* Reordering timer */
7819       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7820       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
7821       {
7822          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
7823          return RFAILED;
7824       }
7825       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7826
7827       drbIdx++;
7828    }
7829
7830    return ROK;
7831 }
7832
7833 /******************************************************************
7834  *
7835  * @brief Fill Radio bearer configuration
7836  *
7837  * @details
7838  *
7839  *    Function : fillRadioBearerConfig
7840  *
7841  *    Functionality: Fill Radio bearer configuration
7842  *
7843  * @params[in] UE control block
7844  *             Radio bearer config pointer
7845  * @return ROK     - success
7846  *         RFAILED - failure
7847  *
7848  * ****************************************************************/
7849 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
7850 {
7851    /* SRB To Add/Mod List */
7852    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7853    if(!radioBearerConfig->srb_ToAddModList)
7854    {
7855       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
7856       return RFAILED;
7857    }
7858    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
7859    {
7860       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
7861       return RFAILED;
7862    }
7863
7864    /* DRB To Add/Mod List */
7865    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7866    if(!radioBearerConfig->drb_ToAddModList)
7867    {
7868       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
7869       return RFAILED;
7870     }
7871    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
7872    {
7873       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
7874       return RFAILED;
7875    }
7876
7877    return ROK;
7878 }
7879
7880 /*******************************************************************
7881  *
7882  * @brief Fill measurement object to add/mod list
7883  *
7884  * @details
7885  *
7886  *    Function : fillMeasObjToAddModList
7887  *
7888  *    Functionality: Fill measurement object to add/mod list
7889  *
7890  * @params[in] Measurement object to add/mod list
7891  * @return ROK     - success
7892  *         RFAILED - failure
7893  *
7894  * ****************************************************************/
7895 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7896 {
7897    uint8_t elementCnt, objIdx;
7898    MeasObjectNR_t *measObject;
7899
7900    elementCnt = 1;
7901    measObjList->list.count = elementCnt;
7902    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
7903
7904    CU_ALLOC(measObjList->list.array, measObjList->list.size);
7905    if(!measObjList->list.array)
7906    {
7907       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
7908       return RFAILED;
7909    }
7910
7911    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7912    {
7913       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7914       if(!measObjList->list.array[objIdx])
7915       {
7916          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
7917          return RFAILED;
7918       }
7919    }
7920
7921    objIdx = 0;
7922    measObjList->list.array[objIdx]->measObjectId = 1;
7923    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
7924    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7925    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7926    {
7927       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
7928       return RFAILED;
7929    }
7930
7931    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7932
7933    /* SSB frequency */
7934    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7935    if(!measObject->ssbFrequency)
7936    {
7937       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
7938       return RFAILED;
7939    }
7940    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
7941
7942    /* Subcarrier spacing */
7943    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7944    if(!measObject->ssbSubcarrierSpacing)
7945    {
7946       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
7947       return RFAILED;
7948    }
7949    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
7950
7951    /* SMTC1 */
7952    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
7953    if(!measObject->smtc1)
7954    {
7955       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
7956       return RFAILED;
7957    }
7958    measObject->smtc1->duration = SSB_MTC__duration_sf1;
7959    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7960    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
7961
7962    /* Absoulute threshold SSB consolidation */
7963    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7964    if(!measObject->absThreshSS_BlocksConsolidation)
7965    {
7966       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
7967       return RFAILED;
7968    }
7969
7970    /* RSRP threshold */
7971    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7972    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
7973    {
7974       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
7975       return RFAILED;
7976    }
7977    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
7978
7979    /* RSRQ threshold */
7980    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7981    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
7982    {
7983       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
7984       return RFAILED;
7985    }
7986    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
7987
7988    /* SINR threshold */
7989    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7990    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
7991    {
7992       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
7993       return RFAILED;
7994    }
7995    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
7996
7997    /* Number of SSBs to average */
7998    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
7999    if(!measObject->nrofSS_BlocksToAverage)
8000    {
8001       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8002       return RFAILED;
8003    }
8004    *(measObject->nrofSS_BlocksToAverage) = 2;
8005
8006    /* Quantity Config index */
8007    measObject->quantityConfigIndex = 1;
8008
8009    /* Offset MO */
8010    /* RSRP offset for SSB */
8011    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8012    if(!measObject->offsetMO.rsrpOffsetSSB)
8013    {
8014       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8015       return RFAILED;
8016    }
8017    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8018
8019    /* RSRQ offset for SSB */
8020    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8021    if(!measObject->offsetMO.rsrpOffsetSSB)
8022    {
8023       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8024       return RFAILED;
8025    }
8026    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8027
8028    /* SINR offset for SSB */
8029    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8030    if(!measObject->offsetMO.sinrOffsetSSB)
8031    {
8032       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8033       return RFAILED;
8034    }
8035    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8036
8037    return ROK;
8038 }
8039
8040 /*******************************************************************
8041  *
8042  * @brief Fill Report configuration to Add/mod list
8043  *
8044  * @details
8045  *
8046  *    Function : fillReportCfgToAddModList
8047  *
8048  *    Functionality: Fill Report configuration to Add/mod list
8049  *
8050  * @params[in] Report Config To Add/Mod List
8051  * @return ROK     - success
8052  *         RFAILED - failure
8053  *
8054  * ****************************************************************/
8055 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8056 {
8057    uint8_t elementCnt;
8058    uint8_t reportCfgIdx;
8059    ReportConfigToAddMod_t *reportCfg;
8060    ReportConfigNR_t *reportCfgNr;
8061    EventTriggerConfig_t *eventTriggCfg;
8062
8063    elementCnt = 1;
8064    reportCfgList->list.count = elementCnt;
8065    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8066
8067    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8068    if(!reportCfgList->list.array)
8069    {
8070       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8071       return RFAILED;
8072    }
8073
8074    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8075    {
8076       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8077       if(!reportCfgList->list.array[reportCfgIdx])
8078       {
8079          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8080          return RFAILED;
8081       }
8082    }
8083
8084    reportCfgIdx = 0;
8085    reportCfg = reportCfgList->list.array[reportCfgIdx];
8086    reportCfg->reportConfigId = 1;
8087    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8088
8089    /* Report Configuration for NR */
8090    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8091    if(!reportCfg->reportConfig.choice.reportConfigNR)
8092    {
8093       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8094       return RFAILED;
8095    }
8096    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8097
8098    /* Report Type */
8099    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8100    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8101    if(!reportCfgNr->reportType.choice.eventTriggered)
8102    {
8103       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8104       return RFAILED;
8105    }
8106    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8107
8108    /* Event 3 */
8109    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8110    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8111    if(!eventTriggCfg->eventId.choice.eventA3)
8112    {
8113       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8114       return RFAILED;
8115    }
8116
8117    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8118    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8119    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8120    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8121    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8122    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8123
8124    /* Reference Signal Type */
8125    eventTriggCfg->rsType = NR_RS_Type_ssb;
8126
8127    /* Report Interval */
8128    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8129
8130    /* Report Amount */
8131    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8132
8133    /* Report Quantity cell */
8134    eventTriggCfg->reportQuantityCell.rsrp = true;
8135    eventTriggCfg->reportQuantityCell.rsrq = false;
8136    eventTriggCfg->reportQuantityCell.sinr = false;
8137
8138    /* Maximum reported cells */
8139    eventTriggCfg->maxReportCells = 3;
8140
8141    /* Report qunatity RS Indexes */
8142    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8143    if(!eventTriggCfg->reportQuantityRS_Indexes)
8144    {
8145       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8146       return RFAILED;
8147    }
8148    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8149    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8150    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8151
8152    /* Maximum number of RS indexes to report */
8153    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8154    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8155    {
8156       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8157       return RFAILED;
8158    }
8159    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8160
8161    /* Include Beam measurement */
8162    eventTriggCfg->includeBeamMeasurements = false;
8163
8164    return ROK;
8165 }
8166
8167 /*******************************************************************
8168  *
8169  * @brief Fill measurement Id to add/mod list
8170
8171  * @details
8172  *
8173  *    Function : fillMeasIdToAddModList
8174  *
8175  *    Functionality: Fill measurement Id to add/mod list
8176  *
8177  * @params[in] Measurement Id to add/mod list
8178  * @return ROK     - success
8179  *         RFAILED - failure
8180  *
8181  * ****************************************************************/
8182 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8183 {
8184    uint8_t elementCnt;
8185    uint8_t measIdIdx;
8186
8187    elementCnt = 1;
8188    measIdList->list.count = elementCnt;
8189    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8190
8191    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8192    if(!measIdList->list.array)
8193    {
8194       return RFAILED;
8195    }
8196
8197    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8198    {
8199       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8200       if(!measIdList->list.array[measIdIdx])
8201       {
8202          return RFAILED;
8203       }
8204
8205       measIdIdx=0;
8206       measIdList->list.array[measIdIdx]->measId = 1;
8207       measIdList->list.array[measIdIdx]->measObjectId = 1;
8208       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8209    }
8210    return ROK;
8211 }
8212
8213 /*******************************************************************
8214  *
8215  * @brief Fill s-measurement configuration
8216  *
8217  * @details
8218  *
8219  *    Function : fillSMeasConfig
8220  *
8221  *    Functionality: Fill s-measurement configuration
8222  *
8223  * @params[in] s-Measurement config
8224  * @return ROK     - success
8225  *         RFAILED - failure
8226  *
8227  * ****************************************************************/
8228 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8229 {
8230    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8231    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8232
8233    return ROK;
8234 }
8235
8236 /*******************************************************************
8237  *
8238  * @brief Fill quantity config
8239  *
8240  * @details
8241  *
8242  *    Function : fillQunatityConfig
8243  *
8244  *    Functionality: Fill quantity config
8245  *
8246  * @params[in] Quantity Config
8247  * @return ROK     - success
8248  *         RFAILED - failure
8249  *
8250  * ****************************************************************/
8251 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8252 {
8253    uint8_t elementCnt = 0;
8254    uint8_t quanCfgIdx = 0;
8255    QuantityConfigNR_t *quantityCfgNr;
8256
8257    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8258    if(!quantityCfg->quantityConfigNR_List)
8259    {
8260       return RFAILED;
8261    }
8262
8263    elementCnt = 1;
8264    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8265    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8266
8267    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8268    if(!quantityCfg->quantityConfigNR_List->list.array)
8269    {
8270       return RFAILED;
8271    }
8272
8273    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8274    {
8275       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8276       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8277       {
8278          return RFAILED;
8279       }
8280    }
8281
8282    quanCfgIdx = 0;
8283    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8284
8285    /* Quantity Config of Reference signal */
8286    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8287    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8288    {
8289       return RFAILED;
8290    }
8291    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8292
8293    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8294    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8295    {
8296       return RFAILED;
8297    }
8298    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8299
8300    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8301    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8302    {
8303       return RFAILED;
8304    }
8305    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8306
8307    /* Quantity Config RS index */
8308    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8309    if(!quantityCfgNr->quantityConfigRS_Index)
8310    {
8311       return RFAILED;
8312    }
8313
8314    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8315    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8316    {
8317       return RFAILED;
8318    }
8319    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8320
8321    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8322    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8323    {
8324       return RFAILED;
8325    }
8326    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8327
8328    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8329    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8330    {
8331       return RFAILED;
8332    }
8333    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8334
8335    return ROK;
8336 }
8337
8338 /*******************************************************************
8339  *
8340  * @brief Fill measurement configuration
8341  *
8342  * @details
8343  *
8344  *    Function : fillMeasConfig
8345  *
8346  *    Functionality: Fill measurement configuration
8347  *
8348  * @params[in] Measurement config
8349  * @return ROK     - success
8350  *         RFAILED - failure
8351  *
8352  * ****************************************************************/
8353 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8354 {
8355    /* Measurement object to add/mod list */
8356    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8357    if(!measConfig->measObjectToAddModList)
8358    {
8359       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8360       return RFAILED;
8361    }
8362    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8363    {
8364       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8365       return RFAILED;
8366    }
8367
8368    /* Report Config To add/mod list */
8369    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8370    if(!measConfig->reportConfigToAddModList)
8371    {
8372       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8373       return RFAILED;
8374    }
8375    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8376    {
8377       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8378       return RFAILED;
8379    }
8380
8381    /* Measurement Id to add/mod list */
8382    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8383    if(!measConfig->measIdToAddModList)
8384    {
8385       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8386       return RFAILED;
8387    }
8388    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8389    {
8390       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8391       return RFAILED;
8392    }
8393
8394    /* S-Measurement config */
8395    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8396    if(!measConfig->s_MeasureConfig)
8397    {
8398       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8399       return RFAILED;
8400    }
8401    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8402    {
8403       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8404       return RFAILED;
8405    }
8406
8407    /* Qunatity Config */
8408    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8409    if(!measConfig->quantityConfig)
8410    {
8411       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8412       return RFAILED;
8413    }
8414    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8415    {
8416       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8417       return RFAILED;
8418    }
8419
8420 return ROK;
8421 }
8422
8423 /*******************************************************************
8424  *
8425  * @brief Fill RRC reconfiguration non-critical extension IE
8426  *
8427  * @details
8428  *
8429  *    Function : fillRrcReconfigNonCriticalExt
8430  *
8431  *    Functionality: Fill RRC reconfiguration non-critical extension
8432  *
8433  * @params[in] RRC Reconfig Non-critical extension
8434  * @return ROK     - success
8435  *         RFAILED - failure
8436  *
8437  * ****************************************************************/
8438 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8439 {
8440    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8441    if(!rrcRecfg->masterCellGroup)
8442    {
8443       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8444       return RFAILED;
8445    }
8446
8447    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8448    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8449    if(!rrcRecfg->masterCellGroup->buf)
8450    {
8451       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8452       return RFAILED;
8453    }
8454    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8455
8456 #if 0
8457    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8458     * received from DU */
8459    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8460    {
8461       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8462       return RFAILED;
8463    }
8464 #endif
8465
8466    return ROK;
8467 }
8468
8469 /*******************************************************************
8470  *
8471  * @brief Fill RRC reconfiguration structure
8472  *
8473  * @details
8474  *
8475  *    Function : fillRrcReconfig
8476  *
8477  *    Functionality: Fill RRC reconfiguration
8478
8479  *
8480  * @params[in] UE Cb
8481  *             RRC reconfiguration structure
8482  * @return ROK     - success
8483  *         RFAILED - failure
8484  *
8485  * ****************************************************************/
8486 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8487 {
8488    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8489
8490    rrcReconfig->rrc_TransactionIdentifier = 1;
8491    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8492
8493    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8494    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8495    {
8496       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8497       return RFAILED;
8498    }
8499
8500    /* Radio Bearer Configuration */
8501    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8502    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8503    {
8504       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8505       return RFAILED;
8506    }
8507    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8508    {
8509       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8510       return RFAILED;
8511    }
8512
8513    /* Measurement Configuration */
8514    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8515    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8516    {
8517       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8518       return RFAILED;
8519    }
8520    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8521    {
8522       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8523       return RFAILED;
8524    }
8525
8526    /* Non Critical extension */
8527    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8528    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8529    {
8530       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8531       return RFAILED;
8532    }
8533    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8534    {
8535       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8536       return RFAILED;
8537    }
8538    return ROK;
8539 }
8540
8541 /*******************************************************************
8542  *
8543  * @brief Fill RRC reconfiguration Octet string
8544  *
8545  * @details
8546  *
8547  *    Function : fillRrcReconfigBuf
8548  *
8549  *    Functionality: Fill RRC reconfiguration octet string
8550
8551  *
8552  * @params[in] OCTET_STRING_t buffer
8553  * @return ROK     - success
8554  *         RFAILED - failure
8555  *
8556  * ****************************************************************/
8557 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8558 {
8559    uint8_t          ret = RFAILED;
8560    asn_enc_rval_t   encRetVal;
8561    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8562    rrcReconfig = &rrcRecfg;
8563
8564    while(true)
8565    {
8566       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8567       {
8568          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8569          break;
8570       }
8571
8572       /* Encode RRC Reconfiguration */
8573       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8574       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8575       encBufSize = 0;
8576       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8577
8578       /* Encode results */
8579       if(encRetVal.encoded == ENCODE_FAIL)
8580       {
8581          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8582                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8583          break;
8584       }
8585       else
8586       {
8587          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8588          for(int i=0; i< encBufSize; i++)
8589          {
8590             DU_LOG("%x",encBuf[i]);
8591          }
8592       }
8593
8594       rrcReconfigBuf->size = encBufSize;
8595       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8596       if(!rrcReconfigBuf->buf)
8597       {
8598          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8599          break;
8600       }
8601       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8602       ret = ROK;
8603       break;
8604    }
8605
8606    freeRrcReconfig(rrcReconfig);
8607    return ret;
8608 }
8609
8610 /*******************************************************************
8611  *
8612  * @brief Fill HO preparation information Octet string
8613  *
8614  * @details
8615  *
8616  *    Function : fillHOPreparationInfoBuf
8617  *
8618  *    Functionality: Fill HO preparation information Octet string
8619
8620  *
8621  * @params[in] HandoverPreparationInformation_t buffer
8622  * @return ROK     - success
8623  *         RFAILED - failure
8624  *
8625  * ****************************************************************/
8626 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8627 {
8628    uint8_t          ret = RFAILED;
8629    asn_enc_rval_t   encRetVal;
8630    HandoverPreparationInformationRrc_t hoPrepInfo;
8631    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8632
8633    while(true)
8634    {
8635
8636       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8637       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8638       if(!hoPrepInfo.criticalExtensions.choice.c1)
8639       {
8640          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8641          break;
8642       }
8643       hoPrepInfo.criticalExtensions.choice.c1->present = \
8644          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8645
8646       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8647          sizeof(HandoverPreparationInformationRrc_IEs_t));
8648       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8649       {
8650          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8651          break;
8652       }
8653       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8654
8655       /* Fill UE Capability RAT container list */
8656       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8657       if(ret != ROK)
8658       {
8659          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8660          break;
8661       }
8662
8663       /* Fill Source config */
8664       hoPrepInfoIe->sourceConfig = NULLP;
8665       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8666       if(!hoPrepInfoIe->sourceConfig)
8667       {
8668          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8669          return RFAILED;
8670       }
8671       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8672
8673       if(ret != ROK)
8674       {
8675          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8676          return RFAILED;
8677       }
8678
8679       hoPrepInfoIe->rrm_Config = NULLP;
8680       hoPrepInfoIe->as_Context = NULLP;
8681       hoPrepInfoIe->nonCriticalExtension = NULLP;
8682
8683       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8684       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8685       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8686       encBufSize = 0;
8687       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8688             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8689
8690       /* Encode results */
8691       if(encRetVal.encoded == ENCODE_FAIL)
8692       {
8693          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8694                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8695          break;
8696       }
8697       else
8698       {
8699          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8700          for(int i=0; i< encBufSize; i++)
8701          {
8702             DU_LOG("%x",encBuf[i]);
8703          }
8704       }
8705
8706       hoPrepInfoBuf->size = encBufSize;
8707       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8708       if(!hoPrepInfoBuf->buf)
8709       {
8710          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8711          break;
8712       }
8713       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8714       ret = ROK;
8715       break;
8716    }
8717    freeHOPreparationInfo(&hoPrepInfo);
8718    return ret;
8719 }
8720
8721 /*******************************************************************
8722  *
8723  * @brief Fills CuToDuContainer
8724  *
8725  * @details
8726  *
8727  *    Function : fillCuToDuContainer
8728  *
8729  *    Functionality: Fills CuToDuContainer
8730  *
8731  * @params[in] pointer to CUtoDURRCInformation_t
8732  *
8733  * @return ROK     - success
8734  *         RFAILED - failure
8735  *
8736  ******************************************************************/
8737
8738 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8739 {
8740    uint8_t elementCnt = 0;
8741    uint8_t ret = ROK;
8742    uint8_t idx, idx2, rrcBufLen;
8743
8744    /* UE Capabulity RAT Container List */
8745    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8746    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8747    {
8748       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8749       return RFAILED;
8750    }
8751    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8752
8753    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8754    if(!rrcMsg->measConfig)
8755    {
8756       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8757       return RFAILED;
8758    }
8759    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8760
8761    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8762    {
8763       /* IE extensions */
8764       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8765       if(rrcMsg->iE_Extensions)
8766       {
8767          elementCnt = 1;
8768          rrcMsg->iE_Extensions->list.count = elementCnt;
8769          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8770
8771          /* Initialize the CUtoDURRCInformation_ExtIEs */
8772          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8773
8774          if(rrcMsg->iE_Extensions->list.array == NULLP)
8775          {
8776             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8777             ret = RFAILED;
8778          }
8779
8780          for(idx=0; idx<elementCnt; idx++)
8781          {
8782             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8783             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8784             {
8785                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8786                ret = RFAILED;
8787             }
8788          }
8789
8790          idx = 0;
8791 #if 0
8792          /* Cell Group Configuration */
8793          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
8794          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8795          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
8796                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
8797          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
8798          idx++;
8799 #endif
8800          /* Handover Preparation Information */
8801          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
8802          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8803          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
8804                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
8805          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
8806       }
8807    }
8808    return ret;
8809 }
8810
8811 /*******************************************************************
8812  *
8813  * @brief Free CuToDuContainer
8814  *
8815  * @details
8816  *
8817  *    Function : FreeCuToDuInfo
8818  *
8819  *    Functionality: Free CuToDuContainer
8820  *
8821  * @params[in] pointer to CUtoDURRCInformation_t
8822  *
8823  * @return ROK     - success
8824  *         RFAILED - failure
8825  *
8826  ******************************************************************/
8827
8828 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8829 {
8830    uint8_t idx, idx2;
8831
8832    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8833    {
8834       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8835          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
8836       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8837    }
8838    if(rrcMsg->iE_Extensions)
8839    {
8840       if(rrcMsg->iE_Extensions->list.array)
8841       {
8842          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
8843          {
8844             if(rrcMsg->iE_Extensions->list.array[idx])
8845             {
8846                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
8847                {
8848                   case ProtocolIE_ID_id_CellGroupConfig:
8849                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8850                      {
8851                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
8852                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
8853
8854                      }
8855                      break;
8856                   default:
8857                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8858                            rrcMsg->iE_Extensions->list.array[idx]->id);
8859                      break;
8860                }
8861             }
8862             break;
8863          }
8864          for(idx2 = 0; idx2 < idx; idx2++)
8865          {
8866             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
8867          }
8868          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8869
8870       }
8871
8872       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8873    }
8874 }
8875 /*******************************************************************
8876  *
8877  * @brief Builds and sends the UE Setup Request
8878  *
8879  * @details
8880  *
8881  *    Function : BuildAndSendUeContextSetupReq
8882  *
8883  *    Functionality: Constructs the UE Setup Request and sends
8884  *                   it to the CU through SCTP.
8885  *
8886  * @params[in]
8887  *
8888  * @return ROK     - success
8889  *         RFAILED - failure
8890  *
8891  * ****************************************************************/
8892 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
8893 {
8894    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
8895    uint8_t   ret= RFAILED, ret1;
8896    uint8_t   elementCnt;
8897    uint8_t   idx, idx1, bufLen, duIdx;
8898    uint32_t  spCellId;
8899    DuDb      *targetDuDb = NULLP;
8900    F1AP_PDU_t           *f1apMsg = NULLP;
8901    UEContextSetupRequest_t *ueSetReq = NULLP;
8902    asn_enc_rval_t encRetVal;        /* Encoder return value */
8903    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8904
8905    while(true)
8906    {
8907       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
8908
8909       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8910       if(f1apMsg == NULLP)
8911       {
8912          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8913          break;
8914       }
8915
8916       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8917       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8918       if(f1apMsg->choice.initiatingMessage == NULLP)
8919       {
8920          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
8921          break;
8922       }
8923
8924       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
8925       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8926       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
8927
8928       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
8929
8930       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8931          elementCnt = 7;
8932       else
8933          elementCnt = 11;
8934       ueSetReq->protocolIEs.list.count = elementCnt;
8935       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
8936
8937       /* Initialize the UESetup members */
8938       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
8939
8940       if(ueSetReq->protocolIEs.list.array == NULLP)
8941       {
8942          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
8943          break;
8944       }
8945
8946       for(idx1=0; idx1<elementCnt; idx1++)
8947       {
8948          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
8949          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
8950          {
8951             break;
8952          }
8953       }
8954
8955       idx = 0;
8956
8957       /*GNB CU UE F1AP ID*/
8958       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8959       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8960       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8961       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
8962
8963       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8964       {
8965          /*GNB DU UE F1AP ID*/
8966          idx++;
8967          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8968          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8969          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8970          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
8971       }
8972
8973       /*Special Cell ID*/
8974       idx++;
8975       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
8976       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8977       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
8978       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8979       {
8980          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
8981          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
8982          /* Since we are supporting only one cell per DU, accessing 0th index to
8983           * get target cell info */
8984          spCellId = targetDuDb->cellCb[0].nrCellId;
8985       }
8986       else
8987          spCellId = ueCb->cellCb->nrCellId;
8988       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
8989       if(Nrcgiret != ROK)
8990       {
8991          break;
8992       }
8993
8994       /*Served Cell Index*/
8995       idx++;
8996       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
8997       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8998       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
8999       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9000
9001       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9002       {
9003          /*CellULConfigured*/
9004          idx++;
9005          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9006          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9007          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9008          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9009       }
9010
9011       /*CUtoDURRCContainer*/
9012       idx++;
9013       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9014       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9015       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9016       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9017       {
9018          break;
9019       }
9020
9021       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9022       {
9023          /*Special Cells to be SetupList*/
9024          idx++;
9025          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9026          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9027          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9028          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9029          if(SplCellListret != ROK)
9030          {
9031             break;
9032          }
9033       }
9034
9035       /*SRBs To Be Setup List*/
9036       idx++;
9037       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9038       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9039       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9040       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9041       if(SrbSetupret != ROK)
9042       {
9043          break;
9044       }
9045
9046       /*DRBs to Be Setup List*/
9047       idx++;
9048       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9049       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9050       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9051       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9052       if(ret1 != ROK)
9053       {
9054          break;
9055       }
9056
9057       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9058       {
9059          /* RRC delivery status request */
9060          idx++;
9061          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9062          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9063          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9064          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9065       }
9066
9067       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9068       idx++;
9069       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9070       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9071       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9072
9073       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9074       bufLen = 4;
9075       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9076       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9077             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9078       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9079       {
9080          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9081          break;
9082       }
9083       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9084       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9085
9086       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9087
9088       /* Encode the F1SetupRequest type as APER */
9089       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9090       encBufSize = 0;
9091       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9092
9093       /* Encode results */
9094       if(encRetVal.encoded == ENCODE_FAIL)
9095       {
9096          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9097                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9098          break;
9099       }
9100       else
9101       {
9102          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9103          for(int i=0; i< encBufSize; i++)
9104          {
9105             DU_LOG("%x",encBuf[i]);
9106          }
9107       }
9108
9109       /* Sending  msg  */
9110       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9111       {
9112          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9113          break;
9114       }
9115       ret = ROK;
9116       break;
9117    }
9118    FreeUeContextSetupReq(f1apMsg);
9119
9120    return ret;
9121 }/* End of BuildAndSendUeContextSetupReq*/
9122
9123 /**********************************************************************
9124  * @brief Function to extractTeId received in UE context setup Response
9125  *
9126  * @details
9127  *
9128  *    Function : extractTeId
9129  *
9130  *    Functionality:
9131  *         - Function to extract TeId
9132  *
9133  * @params[in]
9134  * @return ROK     - success
9135  *         RFAILED - failure
9136  *
9137  **********************************************************************/
9138 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9139 {
9140    uint8_t arrIdx = 0;
9141    uint32_t teId = 0;
9142    GTPTunnel_t *gtpDl = NULLP;
9143
9144    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9145    {
9146       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9147       {
9148          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9149          {
9150             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9151             if(gtpDl->gTP_TEID.size > 0)
9152             {
9153                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9154             }
9155             else
9156                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9157             return(teId);
9158          }
9159       }
9160    }
9161    return teId;
9162 }
9163
9164 /****************************************************************
9165  * @brief Function to add Drb tunnels
9166  *
9167  * @details
9168  *
9169  *    Function : addDrbTunnels
9170  *
9171  *    Functionality:
9172  *         - Function to add Drb tunnels
9173  *
9174  * @params[in]
9175  * @return ROK     - success
9176  *         RFAILED - failure
9177  *
9178  * ****************************************************************/
9179 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9180 {
9181    uint8_t ret = ROK;
9182    EgtpTnlEvt tnlEvt;
9183
9184    if(teId > MAX_TEID || teId < MIN_TEID)
9185    {
9186       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9187    }
9188    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9189    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9190    tnlEvt.lclTeid = teId;
9191    tnlEvt.remTeid = teId;
9192    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9193    if(ret != ROK)
9194    {
9195       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9196    }
9197    return ROK;
9198 }
9199
9200 /****************************************************************
9201  * @brief Function to process Drb Setup List
9202  *
9203  * @details
9204  *
9205  *    Function : procDrbSetupList
9206  *
9207  *    Functionality:
9208  *         - Function to process DRB Setup List
9209  *
9210  * @params[in]
9211  * @return ROK     - success
9212  *         RFAILED - failure
9213  *
9214  * ****************************************************************/
9215 uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList)
9216 {
9217    uint8_t arrIdx = 0;
9218    uint32_t teId = 0;
9219    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9220
9221    if(drbSetupList != NULLP)
9222    {
9223       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9224       {
9225          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9226          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9227          {
9228             /* extracting teId */
9229             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9230             if(teId > 0)
9231             {
9232               if(addDrbTunnels(duId, teId)== ROK)
9233               {
9234                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9235               }
9236             }
9237             else
9238                return RFAILED;
9239          }
9240       }
9241    }
9242    return ROK;
9243 }
9244
9245 /****************************************************************
9246  * @brief Function to process Ue Context Setup Response
9247  *
9248  * @details
9249  *
9250  *    Function : procUeContextSetupResponse
9251  *
9252  *    Functionality:
9253  *         - Function to process Ue Context Setup Response
9254  *
9255  * @params[in]
9256  * @return ROK     - success
9257  *         RFAILED - failure
9258  *
9259  * ****************************************************************/
9260 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9261 {
9262    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9263    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9264    DuDb *duDb = NULLP;
9265    CuUeCb *ueCb = NULLP;
9266    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9267    OCTET_STRING_t *duToCuRrcContainer;
9268
9269    SEARCH_DU_DB(duIdx, duId, duDb);
9270    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9271
9272    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9273    {
9274       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9275       {
9276           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9277              {
9278                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9279                break;
9280              }
9281           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9282              {
9283                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9284                 ueCb = &duDb->ueCb[duUeF1apId-1];
9285                 /* If ue context is not present in du db, then create UE context
9286                  * here. This flow is hit in case of UE handover where UE
9287                  * context is created before UE performs RACH on target DU */
9288                 if(ueCb->gnbDuUeF1apId == 0)
9289                 {
9290                    /* Creating UE context in target DU */
9291                    memset(ueCb, 0, sizeof(CuUeCb));
9292                    ueCb->cellCb = &duDb->cellCb[0];
9293                    ueCb->gnbDuUeF1apId = duUeF1apId;
9294                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9295                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9296                    ueCb->hoInfo.targetDuId = duId;
9297                    (duDb->numUe)++;
9298
9299                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9300                    ueCb->cellCb->numUe++;
9301                 }
9302                 break;
9303              }
9304           case ProtocolIE_ID_id_C_RNTI:
9305              {
9306                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9307                 break;
9308              }
9309           case ProtocolIE_ID_id_DRBs_Setup_List:
9310              {
9311                 /* Adding Tunnels for successful DRB */
9312                 procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9313                 break;
9314              }
9315          case ProtocolIE_ID_id_DUtoCURRCInformation:
9316              {
9317                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9318                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9319                    DUtoCURRCInformation.cellGroupConfig;
9320                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9321                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9322                 {
9323                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9324                    return RFAILED;
9325                 }
9326                 break;
9327              }
9328       }
9329    }
9330
9331    /* If the UE is in handover, UE context modification request is to be sent to
9332     * source DU once UE context setup response is received from target DU */
9333    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9334    {
9335       DuDb *srcDuDb = NULLP;
9336       CuUeCb *ueCbInSrcDu = NULLP;
9337
9338       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9339        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9340       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9341       {
9342          /* UE context setup response is received from target DU. Search all
9343           * DUs to find source DU except this target DU Id.*/
9344          if(cuCb.duInfo[duIdx].duId != duId)
9345          {
9346             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9347             {
9348                /* Check following:
9349                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9350                 * received in UE context setup response since CU UE F1AP ID does not
9351                 * change for UE in handover.
9352                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9353                 */
9354                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9355                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9356                {
9357                   srcDuDb = &cuCb.duInfo[duIdx];
9358                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9359
9360                   /* Store source DU info in the new UE context created in
9361                    * tareget DU */
9362                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9363
9364                   /* Copy the received container to UeCb */
9365                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9366
9367                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9368                   {
9369                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9370                      return RFAILED;
9371                   }
9372                   break;
9373                }
9374             }
9375          }
9376          if(srcDuDb && ueCbInSrcDu)
9377             break;
9378       }
9379    }
9380    else
9381    {
9382       ueCb->f1apMsgDb.dlRrcMsgCount++;
9383       rrcMsgType = setDlRRCMsgType(ueCb);
9384
9385       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9386       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9387       {
9388          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9389          return RFAILED;
9390       }
9391    }
9392
9393    return ROK;
9394 }
9395
9396 /****************************************************************
9397  * @brief Function to process Ul Rrc Msg received from DU
9398  *
9399  * @details
9400  *
9401  *    Function : procUlRrcMsg
9402  *
9403  *    Functionality:
9404  *         - Function to process Ul Rrc Msg received from DU
9405  *
9406  * @params[in]
9407  * @return ROK     - success
9408  *         RFAILED - failure
9409  *
9410  * ****************************************************************/
9411
9412 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9413 {
9414    uint8_t idx, ret, srbId, rrcMsgType, duIdx=0;
9415    uint8_t cuUeF1apId, duUeF1apId;
9416    uint8_t *rrcContainer = NULLP;
9417    uint16_t rrcContLen;
9418    DuDb     *duDb;
9419    CuUeCb   *ueCb;
9420    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9421
9422    ret = ROK;
9423    SEARCH_DU_DB(duIdx, duId, duDb);
9424    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9425
9426    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9427    {
9428       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9429       {
9430          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9431             {
9432                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9433                break;
9434             }
9435          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9436             {
9437                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9438                break;
9439             }
9440          case ProtocolIE_ID_id_SRBID:
9441             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9442             break;
9443
9444          case ProtocolIE_ID_id_RRCContainer:
9445             {
9446                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9447                CU_ALLOC(rrcContainer, rrcContLen);
9448                if(!rrcContainer)
9449                {
9450                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9451                   return RFAILED;
9452                }
9453                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9454
9455                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9456                   return;
9457
9458                break;
9459             }
9460
9461          default:
9462             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9463             break;
9464       }
9465    }
9466
9467    if(srbId == 1)
9468    {
9469       ueCb = &duDb->ueCb[duUeF1apId-1];
9470       ueCb->f1apMsgDb.dlRrcMsgCount++;
9471       rrcMsgType = setDlRRCMsgType(ueCb);
9472       if(rrcMsgType == RRC_SETUP_COMPLETE)
9473       {
9474          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for Security Mode Command");
9475          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9476       }
9477       else if(rrcMsgType == SECURITY_MODE_COMPLETE)
9478       {
9479          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9480          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9481       }
9482       else if(rrcMsgType == REGISTRATION_COMPLETE)
9483       {
9484          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9485          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9486       }
9487       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9488       {
9489          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9490          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9491       }
9492    }
9493    return ret;
9494 }
9495
9496 /****************************************************************
9497  * @brief Build And Send F1ResetAck
9498  *
9499  * @details
9500  *
9501  *    Function : FreeF1ResetAck
9502  *
9503  *    Functionality:
9504  *         - Build And Send  F1ResetRSP
9505  *
9506  *  @params[in]
9507  * @return ROK     - success
9508  *         RFAILED - failure
9509  *
9510  * ****************************************************************/
9511 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9512 {
9513    uint8_t idx;
9514    ResetAcknowledge_t *f1ResetAck;
9515
9516    if(f1apMsg)
9517    {
9518       if(f1apMsg->choice.successfulOutcome)
9519       {
9520          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9521
9522          if(f1ResetAck->protocolIEs.list.array)
9523          {
9524             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9525             {
9526                if(f1ResetAck->protocolIEs.list.array[idx])
9527                {
9528                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9529                }
9530             }
9531             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9532          }
9533          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9534       }
9535       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9536    }
9537 }
9538
9539 /****************************************************************
9540  * @brief Build And Send F1ResetAck
9541  *
9542  * @details
9543  *
9544  *    Function : BuildAndSendF1ResetAck
9545  *
9546  *    Functionality:
9547  *         - Build And Send  F1ResetRSP
9548  *
9549  *  @params[in]
9550  * @return ROK     - success
9551  *         RFAILED - failure
9552  *
9553  * ****************************************************************/
9554
9555 uint8_t BuildAndSendF1ResetAck()
9556 {
9557    uint8_t                idx = 0;
9558    uint8_t                elementCnt = 0;
9559    uint8_t                ret = RFAILED;
9560    F1AP_PDU_t             *f1apMsg = NULL;
9561    ResetAcknowledge_t     *f1ResetAck = NULLP;
9562    asn_enc_rval_t         encRetVal;
9563    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9564
9565    do{
9566       /* Allocate the memory for F1ResetRequest_t */
9567       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9568       if(f1apMsg == NULLP)
9569       {
9570          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9571          break;
9572       }
9573
9574       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9575
9576       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9577       if(f1apMsg->choice.successfulOutcome == NULLP)
9578       {
9579          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9580          break;
9581       }
9582
9583       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9584       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9585       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9586       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9587
9588       elementCnt = 1;
9589
9590       f1ResetAck->protocolIEs.list.count = elementCnt;
9591       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9592
9593       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9594       if(f1ResetAck->protocolIEs.list.array == NULLP)
9595       {
9596          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9597          break;
9598       }
9599
9600       for(idx=0; idx<elementCnt; idx++)
9601       {
9602          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9603          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9604          {
9605             break;
9606          }
9607       }
9608       /*TransactionID*/
9609       idx = 0;
9610       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9611       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9612       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9613       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9614
9615       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9616
9617       /* Encode the F1SetupRequest type as UPER */
9618       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9619       encBufSize = 0;
9620       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9621
9622       /* Check encode results */
9623       if(encRetVal.encoded == ENCODE_FAIL)
9624       {
9625          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9626                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9627          break;
9628       }
9629       else
9630       {
9631          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9632          for(int i=0; i< encBufSize; i++)
9633          {
9634             DU_LOG("%x",encBuf[i]);
9635          }
9636       }
9637
9638       /* Sending msg */
9639       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9640       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9641       {
9642          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9643          break;
9644       }
9645
9646       ret = ROK;
9647       break;
9648    }while(true);
9649
9650    FreeF1ResetAck(f1apMsg);
9651    return ret;
9652 }
9653
9654 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9655 {
9656    uint8_t arrIdx =0;
9657
9658    if(ulInfo->list.array)
9659    {
9660       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9661       {
9662          if(ulInfo->list.array[arrIdx])
9663          {
9664             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9665             {
9666                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9667                {
9668                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9669                   {
9670                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9671                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9672                      gTPTunnel->gTP_TEID.size);
9673                   }
9674                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9675                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9676                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9677                }
9678                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9679                sizeof(GTPTunnel_t));
9680             }
9681             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9682          }
9683       }
9684       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9685    }
9686 }
9687
9688 /*******************************************************************
9689 *
9690 * @brief Deletes the EGTP tunnel
9691 *
9692 * @details
9693 *
9694 *    Function : deleteEgtpTunnel
9695 *
9696 *    Functionality: Deletes the EGTP tunnel
9697 *
9698 * @params[in] uint8_t *buf
9699 *
9700 * @return ROK     - success
9701 *         RFAILED - failure
9702 *
9703 * ****************************************************************/
9704 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
9705 {
9706    uint32_t teId = 0;
9707    EgtpTnlEvt tnlEvt;
9708
9709    teIdStringToInt(buf, &teId);
9710    if(teId > MAX_TEID || teId < MIN_TEID)
9711    {
9712       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
9713       return RFAILED;
9714    }
9715    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9716    tnlEvt.action = EGTP_TNL_MGMT_DEL;
9717    tnlEvt.lclTeid = teId;
9718    tnlEvt.remTeid = teId;
9719    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
9720    {
9721       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
9722    }
9723    return ROK;
9724 }
9725
9726 /*******************************************************************
9727 *
9728 * @brief Builds the Uplink Tunnel Info
9729 *
9730 * @details
9731 *
9732 *    Function : BuildUlTnlInfoforSetupMod
9733 *
9734 *    Functionality: Constructs the UL TnlInfo For DRB list
9735 *
9736 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9737 *
9738 * @return ROK     - success
9739 *         RFAILED - failure
9740 *
9741 * ****************************************************************/
9742 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
9743 {
9744    uint8_t arrIdx;
9745    uint8_t ulCnt;
9746
9747    ulCnt = 1;
9748    ulInfo->list.count = ulCnt;
9749    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
9750    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
9751    if(ulInfo->list.array == NULLP)
9752    {
9753       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9754       return RFAILED;
9755    }
9756    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
9757    {
9758       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9759       if(ulInfo->list.array[arrIdx] == NULLP)
9760       {
9761          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9762          return RFAILED;
9763       }
9764    }
9765
9766    arrIdx = 0;
9767    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
9768    UPTransportLayerInformation_PR_gTPTunnel;
9769
9770    /*GTP TUNNEL*/
9771    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9772          sizeof(GTPTunnel_t));
9773    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
9774    {
9775       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9776       return RFAILED;
9777    }
9778    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9779       transportLayerAddress.size        = 4*sizeof(uint8_t);
9780    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9781          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9782          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9783    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9784          transportLayerAddress.buf == NULLP)
9785    {
9786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9787       return RFAILED;
9788    }
9789
9790    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9791       transportLayerAddress.buf[0] = 192;
9792    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9793       transportLayerAddress.buf[1] = 168;
9794    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9795       transportLayerAddress.buf[2] = 130;
9796    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9797       transportLayerAddress.buf[3] = 82;
9798    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9799       transportLayerAddress.bits_unused = 0;
9800
9801    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
9802    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
9803    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
9804    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
9805
9806    /*GTP TEID*/
9807    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
9808       = 4 * sizeof(uint8_t);
9809    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9810          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9811          gTPTunnel->gTP_TEID.size);
9812    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9813          == NULLP)
9814    {
9815       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9816       return RFAILED;
9817    }
9818    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9819       gTP_TEID.buf[0] = 0;
9820    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9821       gTP_TEID.buf[1] = 0;
9822    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9823       gTP_TEID.buf[2] = 0;
9824    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
9825    {
9826      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
9827       * fetched based on the Drb Id */
9828
9829      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
9830       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
9831                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
9832    }
9833    else
9834    {
9835       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9836         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
9837    }
9838
9839    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
9840    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
9841    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
9842    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
9843    return ROK;
9844 }/*End of BuildULTnlInfo*/
9845
9846 /*******************************************************************
9847 *
9848 * @brief freeing the DRB item
9849 *
9850 * @details
9851 *
9852 *    Function : FreeDrbItem
9853 *
9854 *    Functionality: freeing the DRB item
9855 *
9856 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9857 *
9858 * @return ROK     - success
9859 *         RFAILED - failure
9860 *
9861 * ****************************************************************/
9862
9863 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
9864 {
9865    uint8_t arrIdx =0;
9866    SNSSAI_t *snssai =NULLP;
9867    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
9868
9869    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9870    switch(drbItem->qoSInformation.present)
9871    {
9872       case QoSInformation_PR_NOTHING:
9873          break;
9874       case QoSInformation_PR_eUTRANQoS:
9875          {
9876             if(drbItem->qoSInformation.choice.eUTRANQoS)
9877             {
9878                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9879             }
9880             break;
9881          }
9882       case QoSInformation_PR_choice_extension:
9883          {
9884             if(drbItem->qoSInformation.choice.choice_extension)
9885             {
9886                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
9887
9888                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
9889                if(snssai->sST.buf)
9890                {
9891                   CU_FREE(snssai->sST.buf,snssai->sST.size);
9892                }
9893                if(snssai->sD)
9894                {
9895                   if(snssai->sD->buf)
9896                   {
9897                      CU_FREE(snssai->sD->buf,snssai->sD->size);
9898                   }
9899                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
9900                }
9901
9902                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
9903                if(flowMap->list.array)
9904                {
9905                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
9906                   {
9907                      if(flowMap->list.array[arrIdx] )
9908                      {
9909                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
9910                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
9911                      }
9912                   }
9913                   CU_FREE(flowMap->list.array,flowMap->list.size);
9914                }
9915
9916                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9917             }
9918             break;
9919          }
9920
9921    }
9922    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
9923    if(drbItem->uLConfiguration)
9924    {
9925       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
9926    }
9927 }
9928
9929 /*******************************************************************
9930 *
9931 * @brief filling the DRB setup Mod item
9932 *
9933 * @details
9934 *
9935 *    Function : FillDrbItemToSetupMod
9936 *
9937 *    Functionality: filling the DRB setup Mod item
9938 *
9939 *
9940 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9941 *
9942 * @return ROK     - success
9943 *         RFAILED - failure
9944 *
9945 * ****************************************************************/
9946
9947 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
9948 {
9949    uint8_t ret = ROK;
9950
9951    /*Drb Id */
9952    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
9953    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
9954
9955    /*qoSInformation*/
9956    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9957
9958    switch(drbItem->qoSInformation.present)
9959    {
9960       case QoSInformation_PR_NOTHING:
9961       {
9962          break;
9963       }
9964       case QoSInformation_PR_eUTRANQoS:
9965       {
9966
9967          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9968          if(drbItem->qoSInformation.choice.eUTRANQoS)
9969          {
9970             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9971             return RFAILED;
9972          }
9973          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
9974          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
9975             PriorityLevel_no_priority;
9976
9977          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
9978             Pre_emptionCapability_may_trigger_pre_emption;
9979
9980          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
9981             Pre_emptionVulnerability_pre_emptable;
9982
9983          break;
9984       }
9985       case QoSInformation_PR_choice_extension:
9986       {
9987          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9988          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
9989          {
9990             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9991             return RFAILED;
9992          }
9993
9994          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
9995          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
9996          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
9997          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
9998            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
9999          if(ret != ROK)
10000          {
10001             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10002             return RFAILED;
10003          }
10004
10005          /*SNSSAI*/
10006          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10007                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10008          if(ret != ROK)
10009          {
10010             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10011             return RFAILED;
10012          }
10013
10014          /*Flows mapped to DRB List*/
10015          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10016                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10017           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10018          if(ret != ROK)
10019          {
10020             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10021             return RFAILED;
10022          }
10023       }
10024    }
10025
10026    /*ULUPTNLInformation To Be Setup List*/
10027    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10028       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10029    if(ret != ROK)
10030    {
10031       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10032       return RFAILED;
10033    }
10034
10035    /*RLCMode*/
10036    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10037    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10038
10039    ueCb->numDrb++;
10040    return ROK;
10041 }
10042
10043 /*******************************************************************
10044 *
10045 * @brief Builds the DRB to be Setup Mod ItemIes
10046 *
10047 * @details
10048 *
10049 *    Function : FillDrbItemList
10050 *
10051 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10052 *
10053 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10054 *
10055 * @return ROK     - success
10056 *         RFAILED - failure
10057 *
10058 * ****************************************************************/
10059
10060 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10061 {
10062    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10063    drbItemIe->criticality = Criticality_reject;
10064    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10065
10066    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10067    {
10068       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10069       return RFAILED;
10070    }
10071    return ROK;
10072 }
10073 /*******************************************************************
10074 *
10075 * @brief free the DRB to be Setup Mod list
10076 *
10077 * @details
10078 *
10079 *    Function : FreeDrbToBeSetupModList
10080 *
10081 *    Functionality: free the DRB to be Setup Mod list
10082 *
10083 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10084 *
10085 * @return ROK     - success
10086 *         RFAILED - failure
10087 *
10088 * ****************************************************************/
10089 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10090 {
10091    uint8_t arrIdx =0;
10092    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10093
10094    if(drbSet->list.array)
10095    {
10096       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10097       {
10098          if(drbSet->list.array[arrIdx] != NULLP)
10099          {
10100             if(arrIdx == 0)
10101             {
10102                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10103                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10104             }
10105             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10106          }
10107       }
10108       CU_FREE(drbSet->list.array, drbSet->list.size);
10109    }
10110
10111 }
10112
10113 /*******************************************************************
10114 *
10115 * @brief Builds the DRB to be Setup Mod list
10116 *
10117 * @details
10118 *
10119 *    Function : BuildDrbToBeSetupList
10120 *
10121 *    Functionality: Constructs the DRB to be Setup Mod list
10122 *
10123 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10124 *
10125 * @return ROK     - success
10126 *         RFAILED - failure
10127 *
10128 * ****************************************************************/
10129
10130 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10131 {
10132    uint8_t ret = ROK;
10133    uint8_t arrIdx =0;
10134    uint8_t drbCnt =0;
10135
10136    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10137    drbSet->list.count = drbCnt;
10138    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10139    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10140    if(drbSet->list.array == NULLP)
10141    {
10142       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10143       return  RFAILED;
10144    }
10145
10146    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10147    {
10148       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10149       if(drbSet->list.array[arrIdx] == NULLP)
10150       {
10151          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10152          return  RFAILED;
10153       }
10154
10155       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10156       if(ret != ROK)
10157       {
10158          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10159       }
10160    }
10161
10162    return ret;
10163 }
10164
10165 /*******************************************************************
10166 *
10167 * @brief Filling the DRB to be modified item
10168 *
10169 * @details
10170 *
10171 *    Function : FillDrbToBeModItem
10172 *
10173 *    Functionality: filling the DRB to be modified item
10174 *
10175 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10176 *
10177 * @return ROK     - success
10178 *         RFAILED - failure
10179 *
10180 * ****************************************************************/
10181
10182 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10183 {
10184    uint8_t ret = ROK;
10185    uint drbIdx=0;
10186    DrbInfo *drbToBeMod;
10187
10188    /*Drb Id */
10189    drbItem->dRBID = DRB2 + arrIdx;
10190
10191    /* Search for DRB ID in CU databse */
10192    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10193    {
10194       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10195       {
10196          drbToBeMod = &ueCb->drbList[drbIdx];
10197          break;
10198       }
10199    }
10200
10201    /*qoSInformation*/
10202    drbItem->qoSInformation = NULLP;
10203    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10204    if(drbItem->qoSInformation != NULLP)
10205    {
10206       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10207
10208       switch(drbItem->qoSInformation->present)
10209       {
10210          case QoSInformation_PR_NOTHING:
10211             {
10212                break;
10213             }
10214          case QoSInformation_PR_eUTRANQoS:
10215             {
10216
10217                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10218                if(drbItem->qoSInformation->choice.eUTRANQoS)
10219                {
10220                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10221                   return RFAILED;
10222                }
10223                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10224                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10225                   PriorityLevel_no_priority;
10226
10227                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10228                   Pre_emptionCapability_may_trigger_pre_emption;
10229
10230                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10231                   Pre_emptionVulnerability_pre_emptable;
10232
10233                break;
10234             }
10235          case QoSInformation_PR_choice_extension:
10236             {
10237                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10238                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10239                {
10240                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10241                   return RFAILED;
10242                }
10243
10244                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10245                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10246                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10247                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10248                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10249                if(ret != ROK)
10250                {
10251                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10252                   return RFAILED;
10253                }
10254
10255                /*SNSSAI*/
10256                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10257                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10258                if(ret != ROK)
10259                {
10260                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10261                   return RFAILED;
10262                }
10263
10264                /*Flows mapped to DRB List*/
10265                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10266                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10267                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10268                if(ret != ROK)
10269                {
10270                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10271                   return RFAILED;
10272                }
10273             }
10274       }
10275    }/* End of QoS */
10276
10277    /*ULUPTNLInformation To Be Setup List*/
10278    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10279             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10280    if(ret != ROK)
10281    {
10282       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10283       return RFAILED;
10284    }
10285    return ROK;
10286 }
10287
10288 /*******************************************************************
10289 *
10290 * @brief Builds the DRB to be modified Item IE
10291 *
10292 * @details
10293 *
10294 *    Function : FillDrbToBeModItemList
10295 *
10296 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10297 *
10298 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10299 *
10300 * @return ROK     - success
10301 *         RFAILED - failure
10302 *
10303 * ****************************************************************/
10304
10305 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10306 {
10307    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10308    drbItemIe->criticality = Criticality_reject;
10309    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10310    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10311    {
10312       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10313       return RFAILED;
10314    }
10315
10316    return ROK;
10317 }
10318
10319 /*******************************************************************
10320 *
10321 * @brief Builds the DRB to be modified list
10322 *
10323 * @details
10324 *
10325 *    Function : BuildDrbToBeModList
10326 *
10327 *    Functionality: Constructs the DRB to be modified list
10328 *
10329 * @params[in] DRBs_ToBeModified_List_t *drbSet
10330 *
10331 * @return ROK     - success
10332 *         RFAILED - failure
10333 *
10334 * ****************************************************************/
10335
10336 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10337 {
10338    uint8_t ret = ROK;
10339    uint8_t arrIdx =0;
10340    uint8_t drbCnt =0;
10341
10342    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10343    drbSet->list.count = drbCnt;
10344    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10345    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10346    if(drbSet->list.array == NULLP)
10347    {
10348       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10349       return  RFAILED;
10350    }
10351    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10352    {
10353       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10354       if(drbSet->list.array[arrIdx] == NULLP)
10355       {
10356          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10357          return  RFAILED;
10358       }
10359
10360       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10361       if(ret != ROK)
10362       {
10363          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10364       }
10365    }
10366
10367    return ret;
10368 }
10369
10370 /*******************************************************************
10371 *
10372 * @brief freeing the DRB  item
10373 *
10374 * @details
10375 *
10376 *    Function : FreeModifiedDrbItem
10377 *
10378 *    Functionality: freeing the DRB 2 item
10379 *
10380 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10381 *
10382 * @return ROK     - success
10383 *         RFAILED - failure
10384 *
10385 * ****************************************************************/
10386
10387 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10388 {
10389    uint8_t arrIdx =0;
10390    SNSSAI_t *snssai =NULLP;
10391    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10392
10393    if(drbItem->qoSInformation != NULLP)
10394    {
10395       switch(drbItem->qoSInformation->present)
10396       {
10397          case QoSInformation_PR_NOTHING:
10398             break;
10399          case QoSInformation_PR_eUTRANQoS:
10400             {
10401                if(drbItem->qoSInformation->choice.eUTRANQoS)
10402                {
10403                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10404                }
10405                break;
10406             }
10407          case QoSInformation_PR_choice_extension:
10408             {
10409                if(drbItem->qoSInformation->choice.choice_extension)
10410                {
10411                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10412
10413                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10414                   if(snssai->sST.buf)
10415                   {
10416                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10417                   }
10418                   if(snssai->sD)
10419                   {
10420                      if(snssai->sD->buf)
10421                      {
10422                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10423                      }
10424                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10425                   }
10426
10427                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10428                   if(flowMap->list.array)
10429                   {
10430                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10431                      {
10432                         if(flowMap->list.array[arrIdx] )
10433                         {
10434                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10435                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10436                         }
10437                      }
10438                      CU_FREE(flowMap->list.array,flowMap->list.size);
10439                   }
10440
10441                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10442                }
10443                break;
10444             }
10445       }
10446    }
10447    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10448    if(drbItem->uLConfiguration)
10449    {
10450       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10451    }
10452 }
10453
10454 /*******************************************************************
10455 *
10456 * @brief free the DRB to be modfified list
10457 *
10458 * @details
10459 *
10460 *    Function : FreeDrbToBeModifiedList
10461 *
10462 *    Functionality: free the DRB to be Setup Mod list
10463 *
10464 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10465 *
10466 * @return ROK     - success
10467 *         RFAILED - failure
10468 *
10469 * ****************************************************************/
10470 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10471 {
10472    uint8_t arrIdx =0;
10473    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10474
10475    if(drbSet->list.array)
10476    {
10477       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10478       {
10479          if(drbSet->list.array[arrIdx] != NULLP)
10480          {
10481             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10482             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10483             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10484          }
10485       }
10486       CU_FREE(drbSet->list.array, drbSet->list.size);
10487    }
10488
10489 }
10490
10491 /*******************************************************************
10492  *
10493  * @brief  free the UeContextModification Request
10494  *
10495  * @details
10496  *
10497  *    Function : FreeUeContextModicationRequest
10498  *
10499  *    Functionality : deallocation of memory allocated in UeContextModiification
10500  request
10501  *
10502  * @params[in] F1AP_PDU_t *f1apMsg
10503  *
10504  * @return void
10505 *
10506 * ****************************************************************/
10507 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10508 {
10509    uint8_t arrIdx =0 , ieId=0;
10510    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10511
10512    if(f1apMsg)
10513    {
10514       if(f1apMsg->choice.initiatingMessage)
10515       {
10516          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10517          if(ueContextModifyReq->protocolIEs.list.array)
10518          {
10519             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10520             {
10521                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10522                {
10523                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10524                   switch(ieId)
10525                   {
10526                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10527                         break;
10528                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10529                         break;
10530                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10531                         {
10532                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10533                                  choice.DRBs_ToBeSetupMod_List);
10534                            break;
10535                         }
10536                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10537                         {
10538                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10539                                  choice.DRBs_ToBeModified_List);
10540                            break;
10541                         }
10542                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10543                         break;
10544                     case ProtocolIE_ID_id_RRCContainer:
10545                     {
10546                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10547                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10548                     }
10549
10550                   }
10551                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10552                }
10553             }
10554             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10555          }
10556          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10557       }
10558       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10559    }
10560 }
10561
10562 /*******************************************************************
10563  *
10564  * @brief Builds the Ue Context Modification Req
10565  *
10566  * @details
10567  *
10568  *    Function : BuildAndSendUeContextModificationReq
10569  *
10570  *    Functionality: Constructs the Ue Context Modification Req
10571  *
10572  * @params[in]
10573  *
10574  * @return ROK     - success
10575  *         RFAILED - failure
10576  *
10577  * ****************************************************************/
10578 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10579 {
10580    uint8_t    ieIdx = 0;
10581    uint8_t    elementCnt = 0;
10582    uint8_t    ret = RFAILED;
10583    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10584    F1AP_PDU_t *f1apMsg = NULLP;
10585    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10586    asn_enc_rval_t         encRetVal;
10587    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10588    while(1)
10589    {
10590       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10591       if(f1apMsg == NULLP)
10592       {
10593          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10594          break;
10595       }
10596
10597       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10598
10599       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10600       if(f1apMsg->choice.initiatingMessage == NULLP)
10601       {
10602          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10603          break;
10604       }
10605       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10606       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10607       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10608
10609       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10610
10611       if(action == MODIFY_UE)
10612          elementCnt = 4;
10613       else if(action == QUERY_CONFIG)
10614          elementCnt = 3;
10615       else if(action == RRC_RECONFIG_COMPLETE_IND)
10616          elementCnt = 3;
10617       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10618          elementCnt = 5;
10619
10620       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10621       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10622
10623       /* Initialize the UE context modification members */
10624       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10625       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10626       {
10627          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10628          break;
10629       }
10630
10631       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10632       {
10633          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10634          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10635          {
10636             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10637             break;
10638          }
10639       }
10640
10641       ieIdx=0;
10642       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10643       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10644       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10645                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10646       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10647
10648       ieIdx++;
10649       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10650       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10651       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10652                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10653       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10654
10655       if(action == MODIFY_UE)
10656       {
10657          /* DRB to be setup list */
10658          ieIdx++;
10659          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10660          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10661          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10662                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10663          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10664                   value.choice.DRBs_ToBeSetupMod_List));
10665
10666          /* DRB to be modified list */
10667          ieIdx++;
10668          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10669          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10670          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10671                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10672          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10673                   value.choice.DRBs_ToBeModified_List));
10674
10675          /* TODO: DRB to be release list */
10676
10677          if(ret != ROK)
10678          {
10679             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
10680             break;
10681          }
10682
10683          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
10684       }
10685       else if(action == QUERY_CONFIG)
10686       {
10687          ieIdx++;
10688          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10689          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10690          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10691             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10692          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10693       }
10694       else if(action == RRC_RECONFIG_COMPLETE_IND)
10695       {
10696          ieIdx++;
10697          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10698          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10699          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10700             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
10701          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
10702             RRCReconfigurationCompleteIndicator_true;
10703       }
10704       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10705       {
10706          ieIdx++;
10707          if(action == STOP_DATA_TX)
10708          {
10709             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10710             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10711             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10712             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10713             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10714             TransmissionActionIndicator_stop;
10715          }
10716          else if (action == RESTART_DATA_TX)
10717          {
10718             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10719             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10720             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10721             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10722             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10723             TransmissionActionIndicator_restart;
10724          }
10725
10726          ieIdx++;
10727          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10728          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10729          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10730          UEContextModificationRequestIEs__value_PR_RRCContainer;
10731          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
10732          {
10733             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
10734             return RFAILED;
10735          }
10736
10737          /* RRC delivery status request */
10738          ieIdx++;
10739          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
10740          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10741          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
10742          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
10743       }
10744
10745       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10746
10747       /* Encode the F1SetupRequest type as APER */
10748       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10749       encBufSize = 0;
10750       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10751
10752       /* Encode results */
10753       if(encRetVal.encoded == ENCODE_FAIL)
10754       {
10755          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
10756                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10757          break;
10758       }
10759       else
10760       {
10761          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
10762 #if 0
10763          /* This for loop was going into an infinite loop even though encBufSize
10764           * has a small value. Hence commented this
10765           */
10766          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10767          {
10768             DU_LOG("%x",encBuf[ieIdx]);
10769          }
10770 #endif
10771       }
10772
10773       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10774       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10775       {
10776          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
10777          break;
10778       }
10779
10780       ret = ROK;
10781       break;
10782
10783    }
10784    FreeUeContextModicationRequest(f1apMsg);
10785    return ret;
10786 }
10787
10788 /*****************************************************************i
10789  *
10790 * @brief Free memory allocated for UE Context Release Command
10791 *
10792 * @details
10793 *
10794 *    Function : FreeUeContextReleaseCommand
10795 *
10796 *    Functionality:
10797 *         - Free memory allocated for UE Context Release Command
10798 *
10799 * @params[in] F1AP_PDU_t *f1apMsg
10800 * @return void
10801 *
10802 * *************************************************************/
10803 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
10804 {
10805    uint8_t ieIdx;
10806    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
10807
10808    if(f1apMsg)
10809    {
10810       if(f1apMsg->choice.initiatingMessage)
10811       {
10812          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10813          if(ueReleaseCommand->protocolIEs.list.array)
10814          {
10815             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
10816             {
10817                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10818             }
10819             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
10820          }
10821          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10822       }
10823       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10824    }
10825 }
10826 /*******************************************************************
10827  *
10828  * @brief Builds the Ue Context Release Command
10829  *
10830  * @details
10831 *
10832 *    Function : BuildAndSendUeContextReleaseCommand
10833 *
10834 *    Functionality: Constructs the Ue Context Release Command
10835 *
10836 * @params[in]
10837 *
10838 * @return ROK     - success
10839 *         RFAILED - failure
10840 *
10841 * ****************************************************************/
10842 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
10843 {
10844    bool       memAllocFailed = false;
10845    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
10846    DuDb *duDb;
10847    CuUeCb *ueCb;
10848    F1AP_PDU_t *f1apMsg = NULLP;
10849    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
10850
10851    asn_enc_rval_t         encRetVal;
10852    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
10853
10854    while(true)
10855    {
10856       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10857       if(f1apMsg == NULLP)
10858       {
10859          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
10860          break;
10861       }
10862
10863       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10864
10865       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10866       if(f1apMsg->choice.initiatingMessage == NULLP)
10867       {
10868          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
10869          break;
10870       }
10871       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
10872       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10873       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
10874
10875       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10876
10877       SEARCH_DU_DB(duIdx, duId, duDb);
10878       ueCb = &duDb->ueCb[duUeF1apId-1];
10879       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
10880          elementCnt = 3;
10881       else
10882          elementCnt = 4;
10883
10884       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
10885       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
10886
10887       /* Initialize the UE context modification members */
10888       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
10889       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
10890       {
10891          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
10892          break;
10893       }
10894
10895       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10896       {
10897          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10898          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
10899          {
10900             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
10901             memAllocFailed = true;
10902             break;
10903          }
10904       }
10905
10906       if(memAllocFailed == true)
10907       {
10908          break;
10909       }
10910
10911       ieIdx=0;
10912       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10913       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10914       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10915       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
10916       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
10917
10918       ieIdx++;
10919       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10920       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10921       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10922       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
10923       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
10924
10925       /* Cause of UE context release */
10926       ieIdx++;
10927       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
10928       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10929       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10930                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
10931       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10932       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
10933                                                                                                      CauseRadioNetwork_normal_release;
10934       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
10935       {
10936          /* RRC Container for RRC release */
10937          ieIdx++;
10938          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10939          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10940          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10941                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
10942          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
10943          bufLen =7;
10944          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
10945          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
10946                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
10947          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
10948          {
10949             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
10950             break;
10951          }
10952          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
10953          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
10954       }
10955       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10956
10957       /* Encode the UE Context Release Command type as APER */
10958       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10959       encBufSize = 0;
10960       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10961             encBuf);
10962
10963       /* Encode results */
10964       if(encRetVal.encoded == ENCODE_FAIL)
10965       {
10966          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
10967                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10968          break;
10969       }
10970       else
10971       {
10972          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
10973          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10974          {
10975             DU_LOG("%x",encBuf[ieIdx]);
10976          }
10977       }
10978
10979       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10980       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10981       {
10982          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
10983          break;
10984       }
10985
10986       ret = ROK;
10987       break;
10988
10989    }
10990    FreeUeContextReleaseCommand(f1apMsg);
10991    return ret;
10992 }
10993 /*******************************************************************
10994 *
10995 * @brief process Ue context release request
10996 *
10997 * @details
10998 *
10999 *    Function : procUeContextReleaseReq
11000 *
11001 *    Functionality:
11002 *         - process Ue context release request
11003 *
11004 * @params[in] F1AP_PDU_t *f1apMsg
11005 * @return ROK     - success
11006 *         RFAILED - failure
11007 *
11008 * ****************************************************************/
11009 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11010 {
11011    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11012
11013    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11014    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11015
11016    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11017    {
11018       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11019       {
11020          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11021             {
11022                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11023                break;
11024             }
11025          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11026             {
11027                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11028                break;
11029             }
11030          default:
11031               break;
11032       }
11033    }
11034
11035    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11036    {
11037       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11038       return RFAILED;
11039    }
11040    return ROK;
11041 }
11042 /*******************************************************************
11043 *
11044 * @brief processing of Gnb-DU config update
11045 *
11046 * @details
11047 *
11048 *    Function : procGnbDuUpdate
11049 *
11050 *    Functionality:
11051 *         - processing of Gnb-DU config update
11052 *
11053 * @params[in] F1AP_PDU_t *f1apMsg
11054 * @return ROK     - success
11055 *         RFAILED - failure
11056 *
11057 * ****************************************************************/
11058 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11059 {
11060    bool cellToBeDelete = false;
11061    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11062    uint16_t nrCellId;
11063    DuDb *duDb;
11064    CuCellCb *cellCb;
11065    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11066
11067    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11068    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11069    {
11070       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11071       {
11072          case ProtocolIE_ID_id_TransactionID:
11073             break;
11074          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11075             break;
11076          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11077             {
11078                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11079                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11080                   Served_Cells_To_Delete_List.list.array[0];
11081                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11082                cellToBeDelete = true;
11083                break;
11084             }
11085          case ProtocolIE_ID_id_gNB_DU_ID:
11086             break;
11087       }
11088    }
11089    if(BuildAndSendDUUpdateAck(duId) != ROK)
11090    {
11091       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11092       return RFAILED;
11093    }
11094 #if 0
11095    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11096     * commented this trigger for now */
11097
11098    if(cellToBeDelete == false)
11099    {
11100       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11101       if(BuildAndSendF1ResetReq() != ROK)
11102       {
11103          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11104          return RFAILED;
11105       }
11106    }
11107 #endif
11108    if(cellToBeDelete == true)
11109    {
11110       SEARCH_DU_DB(duIdx, duId, duDb);
11111       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11112       if(cellCb->numUe == 0)
11113       {
11114          memset(cellCb, 0, sizeof(CuCellCb));
11115          duDb->numCells--;
11116       }
11117       else
11118          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11119    }
11120    return ROK;
11121 }
11122
11123 /*******************************************************************
11124 *
11125 * @brief storing slice list in CU database
11126 *
11127 * @details
11128 *
11129 *    Function : buildSliceList
11130 *
11131 *    Functionality:
11132 *         - storing slice list in CU database
11133 *
11134 * @params[in] SliceSupportList_t *sliceSupportList
11135 * @return ROK     - success
11136 *         RFAILED - failure
11137 *
11138 * ****************************************************************/
11139 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11140 {
11141    uint8_t sliceListIdx = 0;
11142
11143    if(sliceSupportList)
11144    {
11145       if(sliceSupportList->list.array)
11146       {
11147          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11148          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11149          {
11150             if(sliceSupportList->list.array[sliceListIdx])
11151             {
11152                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11153                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11154                {
11155                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11156                    return RFAILED;
11157                }
11158                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11159                {
11160                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11161                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11162                }
11163                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11164                {
11165                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11166                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11167                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11168                }
11169             }
11170          }
11171       }
11172    }
11173    return ROK;
11174 }
11175
11176 /****************************************************************
11177  * @brief Function to process Srb Setup Mod List
11178  *
11179  * @details
11180  *
11181  *    Function : procSrbSetupModList
11182  *
11183  *    Functionality:
11184  *         - Function to process SRB Setup Mod List
11185  *
11186  * @params[in]
11187  * @return ROK     - success
11188  *         RFAILED - failure
11189  *
11190  * ****************************************************************/
11191 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11192 {
11193    uint8_t arrIdx = 0, srbIdx;
11194    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11195
11196    if(srbSetupList != NULLP)
11197    {
11198       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11199       {
11200          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11201          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11202          {
11203             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11204             {
11205                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11206                {
11207                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11208                   break;
11209                }
11210             }
11211          }
11212
11213       }
11214    }
11215    return ROK;
11216 }
11217
11218
11219 /****************************************************************
11220  * @brief Function to process Drb Setup Mod List
11221  *
11222  * @details
11223  *
11224  *    Function : procDrbSetupModList
11225  *
11226  *    Functionality:
11227  *         - Function to process DRB Setup Mod List
11228  *
11229  * @params[in]
11230  * @return ROK     - success
11231  *         RFAILED - failure
11232  *
11233  * ****************************************************************/
11234 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11235 {
11236    uint8_t arrIdx = 0, drbIdx;
11237    uint32_t teId = 0;
11238    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11239
11240    if(drbSetupList != NULLP)
11241    {
11242       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11243       {
11244          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11245          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11246          {
11247             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11248             {
11249                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11250                {
11251                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11252                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11253                   break;
11254                }
11255             }
11256
11257             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11258             {
11259             /* extracting teId */
11260             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11261             if(teId > 0)
11262             {
11263               if(addDrbTunnels(duId, teId)== ROK)
11264               {
11265                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11266               }
11267             }
11268             else
11269                return RFAILED;
11270             }
11271          }
11272       }
11273    }
11274    return ROK;
11275 }
11276
11277 /*******************************************************************
11278 *
11279 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11280 *
11281 * @details
11282 *
11283 *    Function : procServedCellPlmnList
11284 *
11285 *    Functionality:
11286 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11287 *         SNSSAI list
11288 *
11289 * @params[in] F1AP_PDU_t *f1apMsg
11290 * @return ROK     - success
11291 *         RFAILED - failure
11292 *
11293 * ****************************************************************/
11294 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11295 {
11296    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11297    ProtocolExtensionContainer_4624P3_t **ieExtend;
11298
11299    if(srvPlmn->list.array)
11300    {
11301       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11302       {
11303          if(srvPlmn->list.array[srvPlmnIdx])
11304          {
11305             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11306             if(*ieExtend)
11307             {
11308                if((*ieExtend)->list.array)
11309                {
11310                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11311                   {
11312                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11313                      {
11314                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11315                         {
11316                            case ProtocolIE_ID_id_TAISliceSupportList:
11317                               {
11318                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11319                                           extensionValue.choice.SliceSupportList) != ROK)
11320                                  {
11321                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11322                                     return RFAILED;
11323                                  }
11324                               }
11325                         }
11326                      }
11327                   }
11328                }
11329             }
11330          }
11331       }
11332    }
11333    return ROK;
11334 }
11335
11336 /****************************************************************
11337  * @brief Function to process Ue Context Modification Response
11338  *
11339  * @details
11340  *
11341  *    Function : procUeContextModificationResponse
11342  *
11343  *    Functionality:
11344  *         - Function to process Ue Context Modification Response
11345  *
11346  * @params[in]
11347  * @return ROK     - success
11348  *         RFAILED - failure
11349  *
11350  * ****************************************************************/
11351 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11352 {
11353    uint8_t idx=0, duIdx=0;
11354    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11355    DuDb *duDb = NULLP;
11356    CuUeCb *ueCb = NULLP;
11357    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11358
11359    SEARCH_DU_DB(duIdx, duId, duDb);
11360    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11361
11362    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11363    {
11364       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11365       {
11366           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11367              {
11368                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11369                 break;
11370              }
11371           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11372              {
11373                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11374                 ueCb = &duDb->ueCb[duUeF1apId-1];
11375                 break;
11376              }
11377           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11378              {
11379                 /* Adding Tunnels for successful DRB */
11380                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11381                 break;
11382
11383              }
11384           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11385              {
11386                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11387                 break;
11388              }
11389          case ProtocolIE_ID_id_DUtoCURRCInformation:
11390              {
11391                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11392                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11393                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11394                 {
11395                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11396                    return RFAILED;
11397                 }
11398                 break;
11399              }
11400
11401       }
11402    }
11403
11404    /* If UE is in handover and UE context is not yet created at target DU, then send
11405     * UE context setup request to target DU */
11406    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11407    {
11408       uint8_t ueIdx = 0;
11409       DuDb *tgtDuDb = NULLP;
11410       CuUeCb *ueCbInTgtDu = NULLP;
11411
11412       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11413       if(tgtDuDb)
11414       {
11415          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11416           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11417           * DB */
11418          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11419          {
11420             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11421             {
11422                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11423                break;
11424             }
11425          }
11426
11427          /* If UE context is not found in Target DU DU, send UE context setup
11428           * request */
11429          if(ueCbInTgtDu == NULLP)
11430          {
11431             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
11432             {
11433                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11434                return RFAILED;
11435             }
11436          }
11437       }
11438    }
11439
11440    return ROK;
11441 }
11442
11443 /*******************************************************************
11444 *
11445 * @brief processing of F1 setup request
11446 *
11447 * @details
11448 *
11449 *    Function : procF1SetupReq
11450 *
11451 *    Functionality:
11452 *         - processing of  F1 setup request
11453 *
11454 * @params[in] F1AP_PDU_t *f1apMsg
11455 * @return ROK     - success
11456 *         RFAILED - failure
11457 *
11458 * ****************************************************************/
11459 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11460 {
11461    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11462    uint32_t duId = 0, nrCellId = 0;
11463    DuDb     *duDb = NULLP;
11464    CuCellCb *cellCb = NULLP;
11465    BIT_STRING_t nrcellIdentity;
11466    F1SetupRequest_t *f1SetupReq = NULLP;
11467    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11468    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11469
11470    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11471    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11472    {
11473       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11474       {
11475          case ProtocolIE_ID_id_gNB_DU_ID:
11476            {
11477               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11478               SEARCH_DU_DB(duIdx, duId, duDb);
11479               if(duDb == NULLP)
11480               {
11481                  duDb = &cuCb.duInfo[cuCb.numDu];
11482                  memset(duDb, 0, sizeof(DuDb));
11483                  duDb->duId = duId;
11484                  cuCb.numDu++;
11485                  *destDuId = duId;
11486               }
11487               else
11488                  return;
11489               break;
11490            }
11491          case ProtocolIE_ID_id_gNB_DU_Name:
11492            {
11493               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11494               break;
11495            }
11496          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11497            {
11498                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11499                if(duServedCell->list.array)
11500                {
11501                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11502                   {
11503                      if(duServedCell->list.array[plmnidx])
11504                      {
11505                         switch(duServedCell->list.array[plmnidx]->id)
11506                         {
11507                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11508                            {
11509                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11510                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11511                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11512
11513                               /* TODO : Use bitStringToInt */
11514                               nrCellId = nrcellIdentity.buf[4] >> nrcellIdentity.bits_unused;
11515                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11516                               if(cellCb == NULLP)
11517                               {
11518                                  cellCb = &duDb->cellCb[duDb->numCells];
11519                                  memset(cellCb, 0, sizeof(CuCellCb));
11520                                  cellCb->nrCellId = nrCellId;
11521                                  cellCb->cellStatus = CELL_ACTIVE;
11522                                  duDb->numCells++;
11523                               }
11524                            }
11525                         }
11526                      }
11527                   }
11528                }
11529            }
11530       }
11531    }
11532    if(ret == ROK)
11533    {
11534       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11535    }
11536    else
11537    {
11538        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11539    }
11540 }
11541
11542 /****************************************************************
11543 *
11544 * @brief processing of UE Context Release Complete
11545 *
11546 * @details
11547 *
11548 *    Function : procUeContextReleaseComplete
11549 *
11550 *    Functionality:
11551 *         - processing of UE Context Release Complete
11552 *
11553 * @params[in] F1AP_PDU_t *f1apMsg
11554 * @return ROK     - success
11555 *         RFAILED - failure
11556 *
11557 * ****************************************************************/
11558 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11559 {
11560    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0;
11561    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11562    DuDb *duDb = NULLP;
11563    CuUeCb *ueCb = NULLP;
11564    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11565
11566    SEARCH_DU_DB(duIdx, duId, duDb);
11567    if(!duDb)
11568    {
11569       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11570       return;
11571    }
11572
11573    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11574    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11575    {
11576       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11577       {
11578          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11579             {
11580                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11581                break;
11582             }
11583          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11584             {
11585                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11586                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11587                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11588                {
11589                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11590                   {
11591                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11592                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11593                      {
11594                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11595                         ueCb->cellCb->numUe--;
11596                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
11597                         {
11598                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11599                            duDb->numCells--;
11600                         }
11601                         break;
11602                      }
11603                   }
11604                }
11605                memset(ueCb, 0, sizeof(CuUeCb));
11606                duDb->numUe--;
11607                break;
11608             }
11609       }
11610    }
11611 }
11612
11613 /*******************************************************************
11614  *
11615  * @brief Builds the Paging cell list
11616  *
11617  * @details
11618  *
11619  *    Function : BuildPagingCellList
11620  *
11621  *    Functionality: Build the paging cell list
11622  *
11623  * @params[in] PagingCell_list_t  *pagingCelllist,
11624  *
11625  * @return ROK     - success
11626  *         RFAILED - failure
11627  *
11628  * ****************************************************************/
11629 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11630 {
11631    uint8_t cellIdx =0;
11632    PagingCell_ItemIEs_t *pagingCellItemIes;
11633    PagingCell_Item_t *pagingCellItem;
11634
11635    pagingCelllist->list.count = numCells;
11636    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11637    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11638    if(pagingCelllist->list.array == NULLP)
11639    {
11640       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11641       return RFAILED;
11642    }
11643
11644    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11645    {
11646       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11647       if(pagingCelllist->list.array[cellIdx] == NULLP)
11648       {
11649          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11650          return RFAILED;
11651       }
11652    }
11653
11654    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11655    {
11656       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11657       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
11658       pagingCellItemIes->criticality = Criticality_ignore;
11659       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
11660       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11661
11662       /* Fill NrCgi Information */
11663       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
11664    }
11665
11666    return ROK;
11667 }
11668
11669 /*******************************************************************
11670  *
11671  * @brief Deallocation of memory allocated in paging msg
11672  *
11673  * @details
11674  *
11675  *    Function :FreePagingMsg
11676  *
11677  *    Functionality: Deallocation of memory allocated in paging msg
11678  *
11679  * @params[in] F1AP_PDU_t *f1apMsg
11680  *
11681  * @return void
11682  *
11683  * ****************************************************************/
11684 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
11685 {
11686    uint8_t ieIdx, cellIdx;
11687    Paging_t   *paging;
11688    PagingCell_ItemIEs_t *pagingCellItemIes;
11689    PagingCell_Item_t *pagingCellItem;
11690    PagingCell_list_t  *pagingCelllist;
11691
11692    if(f1apMsg)
11693    {
11694       if(f1apMsg->choice.initiatingMessage)
11695       {
11696          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11697          if(paging->protocolIEs.list.array)
11698          {
11699             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
11700             {
11701                if(paging->protocolIEs.list.array[ieIdx])
11702                {
11703                   switch(paging->protocolIEs.list.array[ieIdx]->id)
11704                   {
11705                      case ProtocolIE_ID_id_UEIdentityIndexValue:
11706                      {
11707                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11708                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11709                         break;
11710                      }
11711
11712                      case ProtocolIE_ID_id_PagingIdentity:
11713                      {
11714                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
11715                         {
11716                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11717                            {
11718                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
11719                               {
11720                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11721                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11722                               }
11723                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
11724                                 sizeof(struct CNUEPagingIdentity));
11725                            }
11726                         }
11727                         break;
11728                      }
11729
11730                      case ProtocolIE_ID_id_PagingCell_List:
11731                      {
11732                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
11733                         if(pagingCelllist->list.array)
11734                         {
11735                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11736                            {
11737                               if(pagingCelllist->list.array[cellIdx])
11738                               {
11739                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11740                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
11741                                   {
11742                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11743                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
11744                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
11745                                   }
11746                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11747                               }
11748                            }
11749                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
11750                         }
11751                         break;
11752                      }
11753                   }
11754                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11755                }
11756             }
11757             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11758          }
11759          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11760       }
11761       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11762    }
11763 }
11764 /*******************************************************************
11765  *
11766  * @brief Builds and sends the paging message if UE is in idle mode
11767  *
11768  * @details
11769  *
11770  *    Function : BuildAndSendPagingMsg
11771  *
11772  *    Functionality: Builds and sends the paging message
11773  *
11774  * @params[in] uint32_t duId, uint8_t gsTmsi
11775  *
11776  * @return ROK     - success
11777  *         RFAILED - failure
11778  *
11779  * ****************************************************************/
11780 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
11781 {
11782    bool       memAllocFailed = false;
11783    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
11784    uint16_t   ueId = 0, duIdx = 0;
11785
11786    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
11787     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
11788    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
11789    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
11790
11791    F1AP_PDU_t *f1apMsg = NULLP;
11792    Paging_t   *paging = NULLP;
11793    DuDb       *duDb;
11794    asn_enc_rval_t         encRetVal;
11795
11796    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
11797
11798    SEARCH_DU_DB(duIdx, duId, duDb);
11799    if(duDb == NULLP)
11800    {
11801       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
11802       return ret;
11803    }
11804
11805    while(true)
11806    {
11807       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11808       if(f1apMsg == NULLP)
11809       {
11810          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
11811          break;
11812       }
11813
11814       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11815
11816       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11817       if(f1apMsg->choice.initiatingMessage == NULLP)
11818       {
11819          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
11820          break;
11821       }
11822       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
11823       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11824       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
11825
11826       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11827
11828       elementCnt = 5;
11829       paging->protocolIEs.list.count = elementCnt;
11830       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
11831
11832       /* Initialize the Paging Message members */
11833       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11834       if(paging->protocolIEs.list.array == NULLP)
11835       {
11836          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
11837          break;
11838       }
11839
11840       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11841       {
11842          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11843          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
11844          {
11845             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11846             memAllocFailed = true;
11847             break;
11848          }
11849       }
11850
11851       if(memAllocFailed == true)
11852       {
11853          break;
11854       }
11855
11856       /* UE Identity Index Value */
11857       ieIdx=0;
11858       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
11859       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11860       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
11861       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
11862       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
11863       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11864             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11865       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
11866       {
11867          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11868          break;
11869       }
11870
11871       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
11872       ueId = gsTmsi % 1024;
11873       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
11874
11875       /* Paging Identity */
11876       ieIdx++;
11877       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
11878       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11879       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
11880       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
11881                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
11882       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
11883             sizeof(struct CNUEPagingIdentity));
11884       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11885       {
11886          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11887          break;
11888       }
11889
11890       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
11891                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
11892
11893       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
11894       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11895             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11896       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
11897       {
11898          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11899          break;
11900       }
11901
11902       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
11903             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
11904
11905       /* Paging Drx */
11906       ieIdx++;
11907       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
11908       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11909       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
11910       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
11911
11912       /* Paging Priority */
11913       ieIdx++;
11914       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
11915       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11916       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
11917       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
11918
11919       /* Paging Cell List */
11920       ieIdx++;
11921       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
11922       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11923       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
11924       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
11925       {
11926          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
11927          break;
11928       }
11929
11930       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11931
11932       /* Encode the UE Context Release Command type as APER */
11933       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11934       encBufSize = 0;
11935       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11936             encBuf);
11937
11938       /* Encode results */
11939       if(encRetVal.encoded == ENCODE_FAIL)
11940       {
11941          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11942                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11943          break;
11944       }
11945       else
11946       {
11947          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
11948          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11949          {
11950             DU_LOG("%x",encBuf[ieIdx]);
11951          }
11952       }
11953
11954       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11955       {
11956          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11957          break;
11958       }
11959
11960       ret = ROK;
11961       break;
11962
11963    }
11964
11965    FreePagingMsg(f1apMsg);
11966    return ret;
11967 }
11968
11969 /*******************************************************************
11970  *
11971  * @brief Handles received F1AP message and sends back response
11972  *
11973  * @details
11974  *
11975  *    Function : F1APMsgHdlr
11976  *
11977  *    Functionality:
11978  *         - Decodes received F1AP control message
11979  *         - Prepares response message, encodes and sends to SCTP
11980  *
11981  * @params[in]
11982  * @return ROK     - success
11983  *         RFAILED - failure
11984  *
11985  * ****************************************************************/
11986 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
11987 {
11988    int i;
11989    char *recvBuf;
11990    MsgLen copyCnt;
11991    MsgLen recvBufLen;
11992    F1AP_PDU_t *f1apMsg = NULLP;
11993    asn_dec_rval_t rval; /* Decoder return value */
11994    F1AP_PDU_t f1apasnmsg ;
11995
11996    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
11997    ODU_PRINT_MSG(mBuf, 0,0);
11998
11999    /* Copy mBuf into char array to decode it */
12000    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12001    CU_ALLOC(recvBuf, (Size)recvBufLen);
12002
12003    if(recvBuf == NULLP)
12004    {
12005       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12006       return;
12007    }
12008    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12009    {
12010       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12011       return;
12012    }
12013
12014    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12015    for(i=0; i< recvBufLen; i++)
12016    {
12017       DU_LOG("%x",recvBuf[i]);
12018    }
12019
12020    /* Decoding flat buffer into F1AP messsage */
12021    f1apMsg = &f1apasnmsg;
12022    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12023
12024    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12025    CU_FREE(recvBuf, (Size)recvBufLen);
12026
12027    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12028    {
12029       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12030       return;
12031    }
12032    DU_LOG("\n");
12033    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12034
12035    switch(f1apMsg->present)
12036    {
12037       case F1AP_PDU_PR_initiatingMessage:
12038          {
12039             switch(f1apMsg->choice.initiatingMessage->value.present)
12040             {
12041                case InitiatingMessage__value_PR_Reset:
12042                   {
12043                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12044                      BuildAndSendF1ResetAck();
12045                      break;
12046                   }
12047
12048                case InitiatingMessage__value_PR_F1SetupRequest:
12049                   {
12050                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12051                      procF1SetupReq(duId, f1apMsg);
12052                      break;
12053                   }
12054
12055                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12056                   {
12057                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12058                      procGnbDuUpdate(*duId, f1apMsg);
12059                      break;
12060                   }
12061                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12062                   {
12063                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12064                      procInitULRRCMsg(*duId, f1apMsg);
12065                      break;
12066                   }
12067                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12068                   {
12069                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12070                      procUlRrcMsg(*duId, f1apMsg);
12071                      break;
12072                   }
12073
12074                case InitiatingMessage__value_PR_RRCDeliveryReport:
12075                   {
12076                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12077                      break;
12078                   }
12079                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12080                   {
12081                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12082                      procUeContextReleaseReq(*duId, f1apMsg);
12083                      break;
12084                   }
12085                default:
12086                   {
12087                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12088                            f1apMsg->choice.initiatingMessage->value.present);
12089                      return;
12090                   }
12091             }/* End of switch(initiatingMessage) */
12092             break;
12093          }
12094
12095       case F1AP_PDU_PR_successfulOutcome:
12096          {
12097             switch(f1apMsg->choice.successfulOutcome->value.present)
12098             {
12099                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12100                   {
12101                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12102                      break;
12103                   }
12104                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12105                   {
12106                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12107                      procUeContextSetupResponse(*duId, f1apMsg);
12108                      break;
12109                   }
12110                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12111                   {
12112                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12113                      procUeContextModificationResponse(*duId, f1apMsg);
12114                      break;
12115                   }
12116                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12117                   {
12118                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12119                       procUeContextReleaseComplete(*duId, f1apMsg);
12120                       break;
12121                   }
12122                default:
12123                   {
12124                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12125                            f1apMsg->choice.successfulOutcome->value.present);
12126                      return;
12127                   }
12128             }/* End of switch(successfulOutcome) */
12129             break;
12130          }
12131       default:
12132          {
12133             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12134             return;
12135          }
12136    }/* End of switch(f1apMsg->present) */
12137
12138 } /* End of F1APMsgHdlr */
12139
12140 /**********************************************************************
12141   End of file
12142  **********************************************************************/