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