src/cu_stub/cu_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "ProtocolIE-Field.h"
  25 #include "ProtocolExtensionField.h"
  26 #include "ProtocolIE-SingleContainer.h"
  27 #include "F1AP-PDU.h"
  28 #include "ModulationOrder.h"
  29 #include "BandNR.h"
  30 #include "UE-CapabilityRAT-Container.h"
  31 #include "UE-CapabilityRAT-ContainerList.h"
  32 #include "UE-CapabilityRAT-ContainerListRRC.h"
  33 #include "HandoverPreparationInformationRrc-IEs.h"
  34 #include "HandoverPreparationInformationRrc.h"
  35 #include "SupportedBandwidth.h"
  36 #include "FeatureSetUplinkPerCC.h"
  37 #include "FeatureSetDownlinkPerCC.h"
  38 #include "FeatureSets.h"
  39 #include "RF-Parameters.h"
  40 #include "UE-NR-Capability.h"
  41 #include "ProtocolExtensionContainer.h"
  42 #include "CellGroupConfigRrc.h"
  43 #include "MAC-CellGroupConfig.h"
  44 #include "SchedulingRequestConfig.h"
  45 #include "SchedulingRequestToAddMod.h"
  46 #include "BSR-Config.h"
  47 #include "TAG-Config.h"
  48 #include "TAG.h"
  49 #include "PHR-Config.h"
  50 #include "RLC-Config.h"
  51 #include "UL-AM-RLC.h"
  52 #include "DL-AM-RLC.h"
  53 #include "LogicalChannelConfig.h"
  54 #include "RLC-BearerConfig.h"
  55 #include "PhysicalCellGroupConfig.h"
  56 #include "SpCellConfig.h"
  57 #include "ServingCellConfig.h"
  58 #include "ControlResourceSet.h"
  59 #include "SearchSpace.h"
  60 #include "PDCCH-Config.h"
  61 #include "PDSCH-TimeDomainResourceAllocation.h"
  62 #include "PDSCH-TimeDomainResourceAllocationList.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "PUCCH-Config.h"
  75 #include "PUCCH-ResourceSet.h"
  76 #include "PUCCH-Resource.h"
  77 #include "PUCCH-format1.h"
  78 #include "PUCCH-FormatConfig.h"
  79 #include "BWP-UplinkDedicated.h"
  80 #include "PUSCH-ServingCellConfig.h"
  81 #include "UplinkConfig.h"
  82 #include "PDSCH-ServingCellConfig.h"
  83 #include "EUTRANQoS.h"
  84 #include "GBR-QosInformation.h"
  85 #include "DRBs-ToBeSetupMod-List.h"
  86 #include "DRBs-ToBeSetupMod-Item.h"
  87 #include "DRBs-Setup-Item.h"
  88 #include "DLUPTNLInformation-ToBeSetup-List.h"
  89 #include "DLUPTNLInformation-ToBeSetup-Item.h"
  90 #include "UPTransportLayerInformation.h"
  91 #include "GTPTunnel.h"
  92 #include "QoSInformation.h"
  93 #include "Cells-to-be-Activated-List.h"
  94 #include "DL-CCCH-Message.h"
  95 #include "SRB-ToAddModList.h"
  96 #include "SRB-ToAddMod.h"
  97 #include "RRCSetup-IEs.h"
  98 #include "RRCSetup.h"
  99 #include "DL-DCCH-Message.h"
 100 #include "RRCReconfiguration-IEs.h"
 101 #include "RRCReconfiguration.h"
 102 #include "DRB-ToAddModList.h"
 103 #include "DRB-ToAddMod.h"
 104 #include "SDAP-Config.h"
 105 #include "SSB-MTC.h"
 106 #include "MeasTiming.h"
 107 #include "MeasTimingList.h"
 108 #include "MeasurementTimingConfigurationRrc-IEs.h"
 109 #include "MeasurementTimingConfigurationRrc.h"
 110 #include "PDCP-Config.h"
 111 #include "RSRP-Range.h"
 112 #include "RSRQ-Range.h"
 113 #include "SINR-Range.h"
 114 #include "ThresholdNR.h"
 115 #include "MeasObjectToAddMod.h"
 116 #include "MeasObjectNR.h"
 117 #include "MeasObjectToAddModList.h"
 118 #include "EventTriggerConfig.h"
 119 #include "ReportConfigNR.h"
 120 #include "ReportConfigToAddMod.h"
 121 #include "ReportConfigToAddModList.h"
 122 #include "MeasIdToAddMod.h"
 123 #include "MeasIdToAddModList.h"
 124 #include "FilterCoefficient.h"
 125 #include "QuantityConfigNR.h"
 126 #include "QuantityConfig.h"
 127 #include "MeasConfigRrc.h"
 128 #include "AS-Config.h"
 129 #include "RRCReconfiguration-v1530-IEs.h"
 130 #include "CNUEPagingIdentity.h"
 131 #include "PagingCell-Item.h"
 132 #include "UL-DCCH-Message.h"
 133
 134 #include "cu_stub_sctp.h"
 135 #include "cu_stub_egtp.h"
 136 #include "cu_f1ap_msg_hdl.h"
 137 #include "cu_stub.h"
 138
 139 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 140 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 141
 142 /*******************************************************************
 143  *
 144  * @brief Sends F1 msg over SCTP
 145  *
 146  * @details
 147  *
 148  *    Function : SendF1APMsg
 149  *
 150  *    Functionality: Sends F1 msg over SCTP
 151  *
 152  * @params[in] Region region
 153  *             Pool pool
 154  * @return ROK     - success
 155  *         RFAILED - failure
 156  *
 157  * ****************************************************************/
 158 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 159 {
 160    Buffer *mBuf = NULLP;
 161
 162    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 163    {
 164       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 165       {
 166          ODU_PRINT_MSG(mBuf, 0,0);
 167
 168          if(sctpSend(duId, mBuf) != ROK)
 169          {
 170             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 171             ODU_PUT_MSG_BUF(mBuf);
 172             return RFAILED;
 173          }
 174       }
 175       else
 176       {
 177          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 178          ODU_PUT_MSG_BUF(mBuf);
 179          return RFAILED;
 180       }
 181       ODU_PUT_MSG_BUF(mBuf);
 182    }
 183    else
 184    {
 185       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 186       return RFAILED;
 187    }
 188
 189    return ROK;
 190 } /* SendF1APMsg */
 191
 192 /********************************************************************
 193  *
 194  * @brief Builds and sends the F1SetupResponse
 195  *
 196  * @details
 197  *
 198  *    Function : BuildAndSendF1SetupRsp
 199  *
 200  *    Functionality: Constructs the F1SetupResponse message and sends
 201  *                   it back to the DU through SCTP.
 202  *
 203  * @params[in] void **buf,Buffer to which encoded pattern is written into
 204  * @params[in] int *size,size of buffer
 205  *
 206  * @return ROK     - success
 207  *         RFAILED - failure
 208  *
 209  * ****************************************************************/
 210 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 211 {
 212    uint8_t    idx,ieIdx;
 213    uint8_t    elementCnt,cellCnt;
 214    F1AP_PDU_t         *f1apMsg = NULL;
 215    F1SetupResponse_t  *f1SetupRsp;
 216    GNB_CU_Name_t      *cuName;
 217    Cells_to_be_Activated_List_t *cellToActivate;
 218    RRC_Version_t      *rrcVer;
 219    asn_enc_rval_t     encRetVal;
 220    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 221
 222    /* Allocate the memory for F1SetupRequest_t */
 223    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 224    if(f1apMsg == NULLP)
 225    {
 226       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 227       return RFAILED;
 228    }
 229    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 230
 231    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 232    if(f1apMsg->choice.successfulOutcome == NULLP)
 233    {
 234       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 235       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 236       return RFAILED;
 237    }
 238
 239    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 240    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 241    f1apMsg->choice.successfulOutcome->value.present = \
 242                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 243    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 244
 245    elementCnt = 4;
 246    f1SetupRsp->protocolIEs.list.count = elementCnt;
 247    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 248
 249    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 250          elementCnt * sizeof(F1SetupResponseIEs_t *));
 251    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 252    {
 253       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 254       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 255       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 256       return RFAILED;
 257    }
 258
 259    for(idx=0; idx<elementCnt; idx++)
 260    {
 261       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 262             sizeof(F1SetupResponseIEs_t));
 263       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 264       {
 265          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 266                elementCnt * sizeof(F1SetupResponseIEs_t *));
 267          CU_FREE(f1apMsg->choice.successfulOutcome, \
 268                sizeof(SuccessfulOutcome_t));
 269          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 270          return RFAILED;
 271       }
 272    }
 273
 274    /*TransactionID*/
 275    idx = 0;
 276    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 277    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 278    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 279                                                             F1SetupResponseIEs__value_PR_TransactionID;
 280    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 281                                                                         TRANS_ID;
 282
 283    /*CU Name*/
 284    idx++;
 285    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 286    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 287    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 288                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 289    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 290    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 291
 292    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 293    if(cuName->buf == NULLP)
 294    {
 295       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 296       {
 297          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 298                sizeof(F1SetupResponseIEs_t));
 299       }
 300       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 301             elementCnt * sizeof(F1SetupResponseIEs_t *));
 302       CU_FREE(f1apMsg->choice.successfulOutcome,\
 303             sizeof(SuccessfulOutcome_t));
 304       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 305       return RFAILED;
 306    }
 307    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 308
 309    /*Cells to be activated list*/
 310    idx++;
 311    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 312                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 313    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 314    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 315                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 316    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 317                     Cells_to_be_Activated_List;
 318    cellCnt=1;
 319    cellToActivate->list.count = cellCnt;
 320    cellToActivate->list.size = \
 321                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 322    CU_ALLOC(cellToActivate->list.array,\
 323          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 324    if(cellToActivate->list.array == NULLP)
 325    {
 326       CU_FREE(cuName->buf, sizeof(cuName->size));
 327       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 328       {
 329          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 330                sizeof(F1SetupResponseIEs_t));
 331       }
 332       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 333             elementCnt * sizeof(F1SetupResponseIEs_t *));
 334       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 335       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 336       return RFAILED;
 337    }
 338    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 339    {
 340       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 341       if(cellToActivate->list.array[ieIdx] == NULLP)
 342       {
 343          CU_FREE(cellToActivate->list.array,\
 344                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 345          CU_FREE(cuName->buf, sizeof(cuName->size));
 346          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 347          {
 348             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 349                   sizeof(F1SetupResponseIEs_t));
 350          }
 351          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 352                elementCnt * sizeof(F1SetupResponseIEs_t *));
 353          CU_FREE(f1apMsg->choice.successfulOutcome, \
 354                sizeof(SuccessfulOutcome_t));
 355          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 356          return RFAILED;
 357       }
 358    }
 359    cellToActivate->list.array[0]->id = \
 360                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 361    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 362    cellToActivate->list.array[0]->value.present = \
 363                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 364    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 365       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 366    CU_ALLOC(cellToActivate->list.array[0]->\
 367          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 368          3*sizeof(uint8_t));
 369    if(cellToActivate->list.array[0]->value.choice.\
 370          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 371    {
 372
 373       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 374       {
 375          CU_FREE(cellToActivate->list.array[ieIdx],\
 376                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 377       }
 378
 379       CU_FREE(cellToActivate->list.array,\
 380             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 381       CU_FREE(cuName->buf, sizeof(cuName->size));
 382       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 383       {
 384          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 385                sizeof(F1SetupResponseIEs_t));
 386       }
 387       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 388             elementCnt * sizeof(F1SetupResponseIEs_t *));
 389       CU_FREE(f1apMsg->choice.successfulOutcome, \
 390             sizeof(SuccessfulOutcome_t));
 391       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 392       return RFAILED;
 393    }
 394    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 395          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 396    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 397       nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
 398    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 399          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 400          cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 401          nRCGI.nRCellIdentity.size);
 402    if(cellToActivate->list.array[0]->value.choice.\
 403          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 404    {
 405       CU_FREE(cellToActivate->list.array[0]->\
 406             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 407             3*sizeof(uint8_t));
 408       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 409       {
 410          CU_FREE(cellToActivate->list.array[ieIdx],\
 411                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 412       }
 413
 414       CU_FREE(cellToActivate->list.array,\
 415             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 416       CU_FREE(cuName->buf, sizeof(cuName->size));
 417       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 418       {
 419          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 420                sizeof(F1SetupResponseIEs_t));
 421       }
 422       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 423             elementCnt * sizeof(F1SetupResponseIEs_t *));
 424       CU_FREE(f1apMsg->choice.successfulOutcome, \
 425             sizeof(SuccessfulOutcome_t));
 426       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 427       return RFAILED;
 428    }
 429    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 430    /* RRC Version */
 431    idx++;
 432    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 433                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 434    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 435    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 436                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 437    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 438    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 439
 440    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 441    if(rrcVer->latest_RRC_Version.buf == NULLP)
 442    {
 443       CU_FREE(cuName->buf, sizeof(cuName->size));
 444       for(ieIdx=0; ieIdx<elementCnt; idx++)
 445       {
 446          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 447                sizeof(F1SetupResponseIEs_t));
 448       }
 449       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 450             elementCnt * sizeof(F1SetupResponseIEs_t *));
 451       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 452       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 453       return RFAILED;
 454    }
 455
 456    /* Need to check RRC Version */
 457    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 458    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 459    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 460    if(rrcVer->iE_Extensions == NULLP)
 461    {
 462       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 463       CU_FREE(cuName->buf, sizeof(cuName->size));
 464       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 465       {
 466          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 467                sizeof(F1SetupResponseIEs_t));
 468       }
 469       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 470             elementCnt * sizeof(F1SetupResponseIEs_t *));
 471       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 472       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 473       return RFAILED;
 474    }
 475    rrcVer->iE_Extensions->list.count = 1;
 476    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 477    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 478          sizeof(struct RRC_Version_ExtIEs *));
 479    if(rrcVer->iE_Extensions->list.array == NULLP)
 480    {
 481       CU_FREE(rrcVer->iE_Extensions,\
 482             sizeof(ProtocolExtensionContainer_4624P81_t));
 483       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 484       CU_FREE(cuName->buf, sizeof(cuName->size));
 485       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 486       {
 487          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 488                sizeof(F1SetupResponseIEs_t));
 489       }
 490       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 491             elementCnt * sizeof(F1SetupResponseIEs_t *));
 492       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 493       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 494       return RFAILED;
 495    }
 496    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 497          sizeof(struct RRC_Version_ExtIEs));
 498    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 499    {
 500       CU_FREE(rrcVer->iE_Extensions->list.array,\
 501             sizeof(struct RRC_Version_ExtIEs *));
 502       CU_FREE(rrcVer->iE_Extensions,\
 503             sizeof(ProtocolExtensionContainer_4624P81_t));
 504       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 505       CU_FREE(cuName->buf, sizeof(cuName->size));
 506       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 507       {
 508          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 509                sizeof(F1SetupResponseIEs_t));
 510       }
 511       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 512             elementCnt * sizeof(F1SetupResponseIEs_t *));
 513       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 514       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 515       return RFAILED;
 516    }
 517    rrcVer->iE_Extensions->list.array[0]->id = \
 518                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 519    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 520    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 521                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 522    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 523       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 524    CU_ALLOC(rrcVer->iE_Extensions->list.\
 525          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 526          3*sizeof(uint8_t));
 527    if(rrcVer->iE_Extensions->list.\
 528          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 529    {
 530       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 531             sizeof(struct RRC_Version_ExtIEs));
 532       CU_FREE(rrcVer->iE_Extensions->list.array,\
 533             sizeof(struct RRC_Version_ExtIEs *));
 534       CU_FREE(rrcVer->iE_Extensions,\
 535             sizeof(ProtocolExtensionContainer_4624P81_t));
 536       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 537       CU_FREE(cuName->buf, sizeof(cuName->size));
 538       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 539       {
 540          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 541                sizeof(F1SetupResponseIEs_t));
 542       }
 543       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 544             elementCnt * sizeof(F1SetupResponseIEs_t *));
 545       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 546       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 547       return RFAILED;
 548    }
 549    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 550       Latest_RRC_Version_Enhanced.buf[0] = 0;
 551    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 552       Latest_RRC_Version_Enhanced.buf[1] = 5;
 553    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 554       Latest_RRC_Version_Enhanced.buf[2] = 15;
 555
 556    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 557
 558    /* Encode the F1SetupRequest type as UPER */
 559    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 560    encBufSize = 0;
 561    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 562
 563    /* Clean up */
 564    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 565    CU_FREE(cuName->buf, sizeof(cuName->size));
 566    for(idx=0; idx<elementCnt; idx++)
 567    {
 568       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 569    }
 570    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 571    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 572    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 573
 574    /* Check encode results */
 575    if(encRetVal.encoded == ENCODE_FAIL)
 576    {
 577       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 578             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 579       return RFAILED;
 580    }
 581    else
 582    {
 583       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 584       for(int i=0; i< encBufSize; i++)
 585       {
 586          DU_LOG("%x",encBuf[i]);
 587       }
 588    }
 589
 590    /* Sending msg */
 591    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 592    {
 593       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 594       return RFAILED;
 595    }
 596
 597    return ROK;
 598 }/* End of BuildAndSendF1SetupRsp */
 599
 600 /*******************************************************************
 601  *
 602  * @brief Builds and sends the DUUpdateAcknowledge
 603  *
 604  * @details
 605  *
 606  *    Function : BuildAndSendDUUpdateAck
 607  *
 608  *    Functionality: Constructs the DU Update Acknowledge message and sends
 609  *                   it to the DU through SCTP.
 610  *
 611  * @params[in]
 612  *
 613  * @return ROK     - success
 614  *         RFAILED - failure
 615  *
 616  * ****************************************************************/
 617
 618 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 619 {
 620    uint8_t   idx;
 621    uint8_t   elementCnt;
 622    F1AP_PDU_t *f1apMsg = NULL;
 623    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 624    asn_enc_rval_t enRetVal; /* Encoder return value */
 625
 626    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 627
 628    /* Allocate the memory for F1SetupRequest_t */
 629    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 630    if(f1apMsg == NULLP)
 631    {
 632       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 633       return RFAILED;
 634    }
 635
 636    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 637
 638    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 639    if(f1apMsg->choice.successfulOutcome == NULLP)
 640    {
 641       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 642       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 643       return RFAILED;
 644    }
 645
 646    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 647    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 648    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 649    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 650
 651    elementCnt = 1;
 652    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 653    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 654
 655    /* Initialize the F1Setup members */
 656    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 657    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 658    {
 659       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 660       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 661       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 662       return RFAILED;
 663    }
 664
 665    for(idx=0; idx<elementCnt; idx++)
 666    {
 667       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 668       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 669       {
 670          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 671          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 672          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 673          return RFAILED;
 674       }
 675    }
 676
 677    /*TransactionID*/
 678    idx = 0;
 679    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 680    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 681    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 682    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 683    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 684
 685    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 686
 687    /* Encode the F1SetupRequest type as UPER */
 688    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 689    encBufSize = 0;
 690    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 691
 692    /* Clean up */
 693    for(idx=0; idx<elementCnt; idx++)
 694    {
 695       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 696    }
 697    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 698    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 699    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 700
 701    /* Checking encode results */
 702    if(enRetVal.encoded == ENCODE_FAIL)
 703    {
 704       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 705       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 706       return RFAILED;
 707    }
 708    else
 709    {
 710       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 711       for(int i=0; i< encBufSize; i++)
 712       {
 713          DU_LOG("%x",encBuf[i]);
 714       }
 715    }
 716
 717    /* Sending msg */
 718    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 719    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 720    {
 721       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 722       return RFAILED;
 723    }
 724
 725    return ROK;
 726
 727 }/* End of BuildAndSendDUUpdateAck*/
 728
 729 /*******************************************************************
 730 *
 731 * @brief deallocating the memory of  F1reset msg
 732 *
 733 * @details
 734 *
 735 *    Function : FreeF1ResetReq
 736 *
 737 *    Functionality :
 738 *         - freeing memory of F1reset request msg
 739 *
 740 * @params[in]
 741 * @return void
 742 *
 743 *
 744 * ****************************************************************/
 745 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 746 {
 747    uint8_t idx = 0;
 748    Reset_t *f1ResetMsg = NULLP;
 749
 750    if(f1apMsg)
 751    {
 752       if(f1apMsg->choice.initiatingMessage)
 753       {
 754          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 755          if(f1ResetMsg->protocolIEs.list.array)
 756          {
 757             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 758             {
 759                if(f1ResetMsg->protocolIEs.list.array[idx])
 760                {
 761                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 762                }
 763             }
 764             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 765          }
 766          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 767       }
 768       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 769    }
 770 }
 771 /*******************************************************************
 772  *
 773  * @brief build ansld ans send f1reset msg
 774  *
 775  * @details
 776  *
 777  *    Function : BuildAndSendF1ResetReq
 778  *
 779  *    Functionality: build and send f1reset msg
 780  *
 781  * @return ROK     - success
 782  *         RFAILED - failure
 783  *
 784  * ****************************************************************/
 785 uint8_t BuildAndSendF1ResetReq()
 786 {
 787    uint8_t          elementCnt=0;
 788    uint8_t          idx=0;
 789    uint8_t          ret= RFAILED;
 790    Reset_t          *f1ResetMsg = NULLP;
 791    F1AP_PDU_t       *f1apMsg = NULLP;
 792    asn_enc_rval_t   encRetVal;
 793    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 794    do
 795    {
 796       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 797       if(f1apMsg == NULLP)
 798       {
 799          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 800          break;
 801       }
 802       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 803       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 804       if(f1apMsg->choice.initiatingMessage == NULLP)
 805       {
 806          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 807          break;
 808       }
 809       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 810       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 811       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 812
 813       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 814
 815       elementCnt = 3;
 816       f1ResetMsg->protocolIEs.list.count = elementCnt;
 817       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 818
 819       /* Initialize the F1Reset members */
 820       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 821       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 822       {
 823          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 824          break;
 825       }
 826       for(idx=0; idx<elementCnt; idx++)
 827       {
 828          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 829          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 830          {
 831             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 832             break;
 833          }
 834       }
 835
 836       /*TransactionID*/
 837       idx=0;
 838       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 839       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 840       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 841       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 842
 843       /*Cause*/
 844       idx++;
 845       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 846       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 847       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 848       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 849       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 850
 851       /*Reset Type*/
 852       idx++;
 853       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 854       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 855       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 856       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 857       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 858
 859       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 860
 861       /* Encode the F1SetupRequest type as APER */
 862       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 863       encBufSize = 0;
 864       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 865             encBuf);
 866
 867       /* Encode results */
 868       if(encRetVal.encoded == ENCODE_FAIL)
 869       {
 870          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 871                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 872          break;
 873       }
 874       else
 875       {
 876          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 877          for(idx=0; idx< encBufSize; idx++)
 878          {
 879             DU_LOG("%x",encBuf[idx]);
 880          }
 881       }
 882
 883       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 884       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 885       {
 886          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 887          break;
 888       }
 889
 890       ret = ROK;
 891       break;
 892    }while(true);
 893
 894    FreeF1ResetReq(f1apMsg);
 895    return ret;
 896 }
 897
 898 /*******************************************************************
 899  *
 900  * @brief Fills Radio Bearer Config
 901  *
 902  * @details
 903  *
 904  *    Function : fillSrbCfg
 905  *
 906  *    Functionality: Fills Radio Bearer Config
 907  *
 908  * @params[in] SRB_ToAddModList *
 909  *
 910  * @return ROK     - success
 911  *         RFAILED - failure
 912  *
 913  * ****************************************************************/
 914 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 915 {
 916    uint8_t elementCnt = 0;
 917    uint8_t idx, ieId, srbIdx = 0;
 918
 919    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 920    {
 921       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 922          elementCnt++;
 923    }
 924
 925    if(bearerCfg != NULLP)
 926    {
 927       bearerCfg->list.count = elementCnt;
 928       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 929       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 930       if(bearerCfg->list.array != NULLP)
 931       {
 932          for(idx = 0; idx < elementCnt; idx++)
 933          {
 934             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 935             if(bearerCfg->list.array[idx] == NULLP)
 936             {
 937                for(ieId = 0; ieId < idx; ieId++)
 938                {
 939                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 940                }
 941                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 942                return RFAILED;
 943             }
 944          }
 945       }
 946       else
 947       {
 948          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 949          return RFAILED;
 950       }
 951
 952       idx = 0;
 953       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 954       {
 955          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 956             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 957       }
 958    }
 959    return ROK;
 960 }
 961
 962 /*******************************************************************
 963  *
 964  * @brief Fills Master CellGroup Info
 965  *
 966  * @details
 967  *
 968  *    Function : fillMasterCellGroup
 969  *
 970  *    Functionality: Fills Master Cell Group IE
 971  *
 972  * @params[in] RRCSetup_IEs_t *
 973  *
 974  * @return ROK     - success
 975  *         RFAILED - failure
 976  *
 977  * ****************************************************************/
 978
 979 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 980 {
 981    uint8_t ret = ROK;
 982    masterCellGroup->buf = NULLP;
 983    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 984    {
 985       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 986       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 987       if(masterCellGroup->buf != NULLP)
 988       {
 989          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
 990       }
 991       else
 992       {
 993          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
 994          ret = RFAILED;
 995       }
 996    }
 997    else
 998    {
 999       ret =  RFAILED;
1000    }
1001    return ret;
1002 }
1003
1004 /*******************************************************************
1005  *
1006  * @brief Fills RRC setup IE
1007  *
1008  * @details
1009  *
1010  *    Function : fillRRCSetupIE
1011  *
1012  *    Functionality: Fills RRC Setup IE
1013  *
1014  * @params[in] RRCSetup_IEs_t *
1015  *
1016  * @return ROK     - success
1017  *         RFAILED - failure
1018  *
1019  * ****************************************************************/
1020
1021 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1022 {
1023    uint8_t ret = ROK, srbIdx = 0;
1024    if(rrcSetupIE)
1025    {
1026       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1027       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1028       {
1029          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1030       }
1031       if(ret == ROK)
1032       {
1033          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1034       }
1035       else
1036       {
1037          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1038          ret = RFAILED;
1039       }
1040
1041       /* If SRB configuration are filled successfully in RRC Setup, mark these
1042        * configurartion as sent to UE */
1043       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1044       {
1045          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1046             ueCb->srbList[srbIdx].cfgSentToUe = true;
1047       }
1048    }
1049    return ret;
1050 }
1051 /*******************************************************************
1052  *
1053  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1054  *
1055  * @details
1056  *
1057  *    Function : fillDlCcchRrcMsg
1058  *
1059  *    Functionality: Fills DL DCCCH Message required for
1060  *                   DLRRCMessageTransfer
1061  *
1062  * @params[in] RRCContainer_t *rrcContainer
1063  *
1064  * @return ROK     - success
1065  *         RFAILED - failure
1066  *
1067  * ****************************************************************/
1068
1069 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1070 {
1071    uint8_t ret = ROK;
1072    uint16_t idx2;
1073    DL_CCCH_Message_t dl_CCCH_Msg;
1074    asn_enc_rval_t    encRetVal;
1075
1076    if(rrcContainer != NULLP)
1077    {
1078       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1079
1080       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1081       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1082       {
1083          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1084          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1085          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1086          {
1087             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1088             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1089                RRCSetup__criticalExtensions_PR_rrcSetup;
1090
1091             /* Fill RRC Setup IE */
1092             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1093                sizeof(RRCSetup_IEs_t));
1094             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1095             {
1096                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1097
1098                if(ret == ROK)
1099                {
1100                   /* encode DL-CCCH message into RRC Container */
1101                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1102                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1103                   encBufSize = 0;
1104                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1105                   /* Encode results */
1106                   if(encRetVal.encoded == ENCODE_FAIL)
1107                   {
1108                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1109                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1110                      return RFAILED;
1111                   }
1112                   else
1113                   {
1114                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1115                      for(int i = 0; i< encBufSize; i++)
1116                      {
1117                         DU_LOG("%x",encBuf[i]);
1118                      }
1119                      rrcContainer->size = encBufSize;
1120                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1121                      if(rrcContainer->buf != NULLP)
1122                      {
1123                         memset(rrcContainer->buf, 0, encBufSize);
1124                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1125                         {
1126                            rrcContainer->buf[idx2] =    encBuf[idx2];
1127                         }
1128                      }
1129                   }
1130                }
1131                else
1132                {
1133                   ret = RFAILED;
1134                }
1135             }
1136             else
1137             {
1138                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1139                ret = RFAILED;
1140             }
1141          }
1142          else
1143          {
1144             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1145             ret = RFAILED;
1146          }
1147       }
1148       else
1149       {
1150          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1151          ret = RFAILED;
1152       }
1153    }
1154    else
1155    {
1156       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1157       ret = RFAILED;
1158    }
1159 }
1160
1161 /*******************************************************************
1162  *
1163  * @brief Fills QOS flow configuration
1164  *
1165  * @details
1166  *
1167  *    Function : fillQosFlowsToAdd
1168  *
1169  *    Functionality: Fills QOS flow configuration
1170  *
1171  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1172  *
1173  * @return ROK     - success
1174  *         RFAILED - failure
1175  *
1176  * ****************************************************************/
1177 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1178 {
1179    uint8_t idx, ied, elementCnt;
1180
1181    elementCnt = 1;
1182    qosFlow->list.count = elementCnt;
1183    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1184    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1185    if(qosFlow->list.array != NULLP)
1186    {
1187       for(idx = 0; idx < elementCnt; idx++)
1188       {
1189          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1190          if(qosFlow->list.array[idx] == NULLP)
1191          {
1192             for(ied = 0; ied < idx; ied++)
1193             {
1194                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1195             }
1196             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1197             return RFAILED;
1198          }
1199       }
1200    }
1201    idx = 0;
1202    *qosFlow->list.array[idx] = 9;
1203    return ROK;
1204 }
1205
1206 /*******************************************************************
1207  *
1208  * @brief Fills CN Assoc for Drb to Add/Mod List
1209  *
1210  * @details
1211  *
1212  *    Function : fillCnAssoc
1213  *
1214  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1215  *
1216  * @params[in] struct DRB_ToAddMod__cnAssociation *
1217  *
1218  * @return ROK     - success
1219  *         RFAILED - failure
1220  *
1221  * ****************************************************************/
1222
1223 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1224 {
1225    uint8_t ret = ROK;
1226
1227    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1228    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1229    {
1230       cnAssoc->choice.eps_BearerIdentity = 5;
1231    }
1232    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1233    {
1234       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1235       if(cnAssoc->choice.sdap_Config)
1236       {
1237          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1238          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1239          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1240          cnAssoc->choice.sdap_Config->defaultDRB = true;
1241          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1242          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1243          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1244                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1245          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1246          {
1247             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1248          }
1249          else
1250          {
1251             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1252             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1253             ret = RFAILED;
1254          }
1255       }
1256       else
1257       {
1258          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1259          ret = RFAILED;
1260       }
1261    }
1262    return ret;
1263 }
1264
1265 /*******************************************************************
1266  *
1267  * @brief Fills Radio Bearer Config for Drb
1268  *
1269  * @details
1270  *
1271  *    Function : fillDrbCfg
1272  *
1273  *    Functionality: Fills Radio Bearer Config for Drb
1274  *
1275  * @params[in] drbId, DRB_ToAddModList *
1276  *
1277  * @return ROK     - success
1278  *         RFAILED - failure
1279  *
1280  * ****************************************************************/
1281 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1282 {
1283    uint8_t idx, ied, ret, elementCnt;
1284
1285    ret = ROK;
1286    if(drbCfg != NULLP)
1287    {
1288       elementCnt = 1;
1289       drbCfg->list.count = elementCnt;
1290       drbCfg->list.size =\
1291                          elementCnt * sizeof(DRB_ToAddMod_t *);
1292       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1293       if(drbCfg->list.array != NULLP)
1294       {
1295          for(idx = 0; idx < elementCnt; idx++)
1296          {
1297             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1298             if(drbCfg->list.array[idx] == NULLP)
1299             {
1300                for(ied = 0; ied < idx; ied++)
1301                {
1302                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1303                }
1304                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1305                return RFAILED;
1306             }
1307          }
1308       }
1309       else
1310       {
1311          return RFAILED;
1312       }
1313       idx = 0;
1314       /* CN ASSOCIATION */
1315       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1316       if(drbCfg->list.array[idx]->cnAssociation)
1317       {
1318          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1319       }
1320       /* DRB */
1321       drbCfg->list.array[idx]->drb_Identity = drbId;
1322    }
1323    return ret;
1324 }
1325
1326 /*******************************************************************
1327  *
1328  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1329  *
1330  * @details
1331  *
1332  *    Function : fillRrcReconfigIE
1333  *
1334  *    Functionality: Fills RRC Reconfig Message required for
1335  *                   DLRRCMessageTransfer
1336  *
1337  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1338  *
1339  * @return ROK     - success
1340  *         RFAILED - failure
1341  *
1342  * ****************************************************************/
1343
1344 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1345 {
1346    uint8_t ret = ROK;
1347    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1348    if(rrcReconfigMsg->radioBearerConfig)
1349    {
1350       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1351       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1352       {
1353          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1354
1355       }
1356       if(ret == ROK)
1357       {
1358          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1359          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1360          {
1361             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1362             if(ret == RFAILED)
1363             {
1364                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1365                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1366                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1367             }
1368          }
1369       }
1370       else
1371       {
1372          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1373          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1374       }
1375    }
1376
1377    return ret;
1378 }
1379 /*******************************************************************
1380  *
1381  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1382  *
1383  * @details
1384  *
1385  *    Function : fillDlDcchRrcMsg
1386  *
1387  *    Functionality: Fills DL DCCH Message required for
1388  *                   DLRRCMessageTransfer
1389  *
1390  * @params[in] RRCContainer_t *rrcContainer
1391  *
1392  * @return ROK     - success
1393  *         RFAILED - failure
1394  *
1395  * ****************************************************************/
1396
1397 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1398 {
1399    uint8_t ret = ROK;
1400    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1401    DL_DCCH_Message_t dl_DCCH_Msg;
1402    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1403    asn_enc_rval_t        encRetVal;
1404
1405    if(rrcContainer != NULLP)
1406    {
1407       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1408
1409       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1410       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1411       {
1412          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1413          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1414          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1415          {
1416             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1417             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1418             if(ret == ROK)
1419             {
1420                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1421                 * configurartion as sent to UE */
1422                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1423                {
1424                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1425                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1426                }
1427                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1428                {
1429                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1430                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1431                }
1432
1433                /* encode DL-DCCH message into RRC Container */
1434                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1435                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1436                encBufSize = 0;
1437                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1438                /* Encode results */
1439                if(encRetVal.encoded == ENCODE_FAIL)
1440                {
1441                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1442                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1443                   return RFAILED;
1444                }
1445                else
1446                {
1447                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1448                   for(int i = 0; i< encBufSize; i++)
1449                   {
1450                      DU_LOG("%x",encBuf[i]);
1451                   }
1452                   rrcContainer->size = encBufSize;
1453                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1454                   if(rrcContainer->buf != NULLP)
1455                   {
1456                      memset(rrcContainer->buf, 0, encBufSize);
1457                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1458                      {
1459                         rrcContainer->buf[idx2] =       encBuf[idx2];
1460                      }
1461                   }
1462                }
1463             }
1464          }
1465          else
1466          {
1467             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1468             ret = RFAILED;
1469          }
1470       }
1471       else
1472       {
1473          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1474          ret = RFAILED;
1475       }
1476    }
1477    else
1478    {
1479       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1480       ret = RFAILED;
1481    }
1482    return ret;
1483 }
1484
1485 /*******************************************************************
1486  *
1487  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1488  *
1489  * @details
1490  *
1491  *    Function : BuildDLRRCContainer
1492  *
1493  *    Functionality: Builds RRC Container IE required for
1494  *                   DLRRCMessageTransfer
1495  *
1496  * @params[in]
1497  *
1498  * @return ROK     - success
1499  *         RFAILED - failure
1500  *
1501  * ****************************************************************/
1502
1503 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1504 {
1505    uint8_t ret, bufLen;
1506
1507    ret =ROK;
1508    if(rrcMsgType == RRC_SETUP)
1509    {
1510       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1511       if(ret == RFAILED)
1512          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1513    }
1514    else if(rrcMsgType == RRC_SETUP_COMPLETE)
1515    {
1516       DU_LOG("\nINFO --> F1AP : Sending Security mode command");
1517       char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1518       bufLen =9;
1519       rrcContainer->size = bufLen;
1520       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1521       if(rrcContainer->buf != NULLP)
1522       {
1523          memset(rrcContainer->buf, 0, bufLen);
1524          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1525       }
1526       else
1527       {
1528          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1529          ret = RFAILED;
1530       }
1531    }
1532    else if(rrcMsgType == SECURITY_MODE_COMPLETE)
1533    {
1534       /*Hardcoded RRC Container from reference logs*/
1535       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1536       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1537       bufLen =14;
1538       rrcContainer->size = bufLen;
1539       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1540       if(rrcContainer->buf != NULLP)
1541       {
1542          memset(rrcContainer->buf, 0, bufLen);
1543          memcpy(rrcContainer->buf, buf, bufLen);
1544       }
1545       else
1546       {
1547          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1548          ret = RFAILED;
1549       }
1550    }
1551    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1552    {
1553       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1554       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1555       if(ret == RFAILED)
1556          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1557    }
1558
1559    return ret;
1560 }
1561
1562 /*******************************************************************
1563  *
1564  * @brief Frees the DLRRCMessageTransfer
1565  *
1566  * @details
1567  *
1568  *    Function : freeDlRrcMessageTransfer
1569  *
1570  *    Functionality: Frees the DLRRCMessageTransfer
1571  *
1572  * @params[in]
1573  *
1574  * @return ROK     - success
1575  *         RFAILED - failure
1576  *
1577  * ****************************************************************/
1578 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1579 {
1580    uint8_t idx=0;
1581    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1582
1583    if(f1apMsg)
1584    {
1585       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1586       if(dlRRCMsg->protocolIEs.list.array)
1587       {
1588          idx = 3;
1589          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1590             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1591          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1592          {
1593             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1594          }
1595          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1596       }
1597       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1598    }
1599 }
1600
1601 /*******************************************************************
1602  *
1603  * @brief Builds and sends the DLRRCMessageTransfer
1604  *
1605  * @details
1606  *
1607  *    Function : BuildAndSendDLRRCMessageTransfer
1608  *
1609  *    Functionality: Constructs the DL RRC Message Transfer and sends
1610  *                   it to the CU through SCTP.
1611  *
1612  * @params[in]
1613  *
1614  * @return ROK     - success
1615  *         RFAILED - failure
1616  *
1617  * ****************************************************************/
1618 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1619 {
1620    uint8_t   elementCnt = 0;
1621    uint8_t  ieId;
1622    uint8_t  idx;
1623    F1AP_PDU_t  *f1apMsg = NULLP;
1624    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1625    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1626
1627    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1628
1629    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1630    if(f1apMsg == NULLP)
1631    {
1632       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1633       return RFAILED;
1634    }
1635
1636    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1637    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1638    if(f1apMsg->choice.initiatingMessage == NULLP)
1639    {
1640       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1641       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1642       return RFAILED;
1643    }
1644
1645    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1646    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1647    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1648    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1649
1650    elementCnt = 4;
1651    dlRRCMsg->protocolIEs.list.count = elementCnt;
1652    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1653
1654    /* Initialize the F1Setup members */
1655    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1656    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1657    {
1658       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1659       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1660       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1661       return RFAILED;
1662    }
1663
1664    for(idx=0; idx<elementCnt; idx++)
1665    {
1666       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1667       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1668       {
1669          for(ieId=0; ieId<idx; ieId++)
1670          {
1671             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1672          }
1673          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1674          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1675          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1676          return RFAILED;
1677       }
1678    }
1679
1680    /* GNB CU UE F1AP ID */
1681    idx = 0;
1682    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1683    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1684    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1685    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1686
1687    /* GNB DU UE F1AP ID */
1688    idx++;
1689    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1690    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1691    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1692    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1693
1694    /* SRBID */
1695    idx++;
1696    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1697    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1698    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1699    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1700
1701    /* RRCContainer */
1702    idx++;
1703    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1704    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1705    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1706    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1707
1708    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1709
1710    /* Encode the F1SetupRequest type as APER */
1711    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1712    encBufSize = 0;
1713    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1714          encBuf);
1715    /* Encode results */
1716    if(encRetVal.encoded == ENCODE_FAIL)
1717    {
1718       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1719             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1720       return RFAILED;
1721    }
1722    else
1723    {
1724       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1725       for(int i=0; i< encBufSize; i++)
1726       {
1727          DU_LOG("%x",encBuf[i]);
1728       }
1729    }
1730
1731    /* Sending  msg  */
1732    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1733    {
1734       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1735       return RFAILED;
1736    }
1737    freeDlRrcMessageTransfer(f1apMsg);
1738    return ROK;
1739 }/* End of BuildAndSendDLRRCMessageTransfer */
1740
1741 /*******************************************************************
1742  *
1743  * @brief Function to set the Dl RRC Msg Type
1744  *
1745  * @details
1746  *
1747  *    Function : setDlRRCMsgType
1748  *
1749  *    Functionality: Constructs the UE Setup Response and sends
1750  *                   it to the DU through SCTP.
1751  *
1752  * @params[in]
1753  *
1754  * @return ROK     - success
1755  *         RFAILED - failure
1756  *
1757  * ****************************************************************/
1758
1759 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1760 {
1761    uint8_t rrcMsgType = 0;
1762    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1763    {
1764       case RRC_SETUP:
1765          rrcMsgType = RRC_SETUP;
1766          break;
1767       case RRC_SETUP_COMPLETE:
1768          rrcMsgType = RRC_SETUP_COMPLETE;
1769          break;
1770       case SECURITY_MODE_COMPLETE:
1771          rrcMsgType = SECURITY_MODE_COMPLETE;
1772          break;
1773       case REGISTRATION_COMPLETE:
1774          rrcMsgType = REGISTRATION_COMPLETE;
1775          break;
1776       case UE_CONTEXT_SETUP_RSP:
1777          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1778          break;
1779       case RRC_RECONFIG_COMPLETE:
1780          rrcMsgType = RRC_RECONFIG_COMPLETE;
1781          break;
1782       default:
1783          break;
1784    }
1785    return rrcMsgType;
1786 }
1787
1788 /*******************************************************************
1789  *
1790  * @brief Extract configuration from CellGroupConfig
1791  *
1792  * @details
1793  *
1794  *    Function : extractCellGroupConfig
1795  *
1796  *    Functionality: Extract configuration from CellGroupConfig
1797  *        and store in local database
1798  *
1799  * @params[in] UE control block
1800  *             Cell Group Config
1801  *
1802  * @return ROK     - success
1803  *         RFAILED - failure
1804  *
1805  * ****************************************************************/
1806 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1807 {
1808    uint8_t rbIdx, srbIdx, drbIdx;
1809    bool    srbFound, drbFound;
1810    SrbInfo *srbCfgDb = NULLP;
1811    DrbInfo *drbCfgDb = NULLP;
1812    RlcLcCfg *rlcLcCfgDb = NULLP;
1813    MacLcCfg *macLcCfgDb = NULLP;
1814    RLC_BearerConfig_t *rlcCfg = NULLP;
1815    RLC_Config_t *rlcLcCfg = NULLP;
1816    LogicalChannelConfig_t *macLcCfg = NULLP;
1817
1818    if(ueCb == NULLP)
1819    {
1820       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
1821       return RFAILED;
1822    }
1823
1824    if(cellGrpCfg == NULLP)
1825    {
1826       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
1827       return RFAILED;
1828    }
1829
1830    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
1831    {
1832       srbFound = false;
1833       drbFound = false;
1834
1835       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
1836
1837       /* Update SRB configuration in local DB */
1838       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
1839       {
1840          /* Search if SRB entry is already present in DB */
1841          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
1842          {
1843             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
1844             {
1845               srbCfgDb = &ueCb->srbList[srbIdx];
1846               srbFound = true;
1847               break;
1848             }
1849          }
1850
1851          /* If not, add SRB to UE CB's SRB list */
1852          if(!srbFound)
1853          {
1854             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
1855             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
1856             ueCb->numSrb++;
1857          }
1858
1859          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1860          srbCfgDb->cfgSentToUe = false;
1861          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
1862          macLcCfgDb = &srbCfgDb->macLcCfg;
1863       }
1864
1865       /* Update DRB configuration in local DB */
1866       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
1867       {
1868          /* Search if DRB entry is already present in DB */
1869          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
1870          {
1871             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
1872             {
1873               drbCfgDb = &ueCb->drbList[drbIdx];
1874               drbFound = true;
1875               break;
1876             }
1877          }
1878
1879          /* If not, add DRB to UE CB's SRB list */
1880          if(!drbFound)
1881          {
1882             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
1883             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
1884             ueCb->numDrb++;
1885          }
1886
1887          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1888          drbCfgDb->cfgSentToUe = false;
1889          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
1890          macLcCfgDb = &drbCfgDb->macLcCfg;
1891       }
1892
1893
1894       /* Update RLC configuration for this RB */
1895       rlcLcCfg = rlcCfg->rlc_Config;
1896       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
1897       switch(rlcLcCfgDb->rlcMode)
1898       {
1899          case RLC_Config_PR_am:
1900             {
1901                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
1902                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
1903                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
1904                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
1905                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
1906
1907                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
1908                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
1909                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
1910                break;
1911             }
1912
1913          case RLC_Config_PR_um_Bi_Directional:
1914             {
1915                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
1916
1917                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
1918                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
1919                break;
1920             }
1921       }
1922
1923       /* Update MAC configuration for this LC */
1924       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
1925       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
1926       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
1927       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
1928       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
1929       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
1930    }
1931    return ROK;
1932 }
1933
1934 /*******************************************************************
1935  *
1936  * @brief Function to decode DU to CU RRC container
1937  *
1938  * @details
1939  *
1940  *    Function : extractDuToCuRrcCont
1941  *
1942  *    Functionality: Function to decode DU to CU RRC container
1943  *
1944  * @params[in] UE Cb
1945  *             RRC conatiner octect string to be decoded
1946  *
1947  * @return ROK     - success
1948  *         RFAILED - failure
1949  *
1950  * ****************************************************************/
1951 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
1952 {
1953    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
1954    asn_dec_rval_t rval; /* Decoder return value */
1955
1956    /* Copy the received container to UeCb */
1957    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
1958
1959    /* Decoding DU to CU RRC container octet string to cell group config */
1960    cellGrpCfgMsg = &cellGrpCfg;
1961    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
1962
1963    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
1964
1965    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1966    {
1967       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
1968       return RFAILED;
1969    }
1970    printf("\n");
1971    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
1972
1973    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
1974    {
1975       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
1976       return RFAILED;
1977    }
1978
1979    return ROK;
1980 }
1981
1982 /*******************************************************************
1983  *
1984  * @brief Function to build Initial UL RRC Message
1985  *
1986  * @details
1987  *
1988  *    Function : procInitULRRCMsg
1989  *
1990  *    Functionality: Function to build Initial UL RRC Message
1991  *
1992  * @params[in]
1993  *
1994  * @return ROK     - success
1995  *         RFAILED - failure
1996  *
1997  * ****************************************************************/
1998
1999 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2000 {
2001    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2002    uint8_t ret =ROK;
2003    uint16_t cellIdx=0, nrCellId = 0;
2004    uint32_t crnti;
2005    DuDb     *duDb;
2006    CuCellCb *cellCb;
2007    CuUeCb   *ueCb;
2008    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2009
2010    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2011
2012    SEARCH_DU_DB(duIdx, duId, duDb);
2013    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2014
2015    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2016    {
2017       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2018       {
2019          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2020             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2021             break;
2022
2023          case ProtocolIE_ID_id_NRCGI:
2024             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2025             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2026             if(cellCb == NULLP)
2027                return RFAILED;
2028             break;
2029
2030          case ProtocolIE_ID_id_C_RNTI:
2031             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2032             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2033             {
2034                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2035                memset(ueCb, 0, sizeof(CuUeCb));
2036                ueCb->cellCb = cellCb;
2037                ueCb->crnti = crnti;
2038                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2039                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2040                ueCb->state = UE_ATTACH_IN_PROGRESS;
2041                (duDb->numUe)++;
2042
2043                cellCb->ueCb[cellCb->numUe] = ueCb;
2044                cellCb->numUe++;
2045             }
2046             break;
2047
2048          case ProtocolIE_ID_id_RRCContainer:
2049             break;
2050
2051          case ProtocolIE_ID_id_DUtoCURRCContainer:
2052             {
2053                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2054                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2055                {
2056                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2057                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2058                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2059                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2060                   {
2061                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2062                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2063                         ueCb->f1apMsgDb.duToCuContainer.size);
2064                   }
2065                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2066                   {
2067                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2068                      ret = RFAILED;
2069                   }
2070                }
2071                else
2072                {
2073                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2074                   ret = RFAILED;
2075                }
2076                break;
2077             }
2078
2079          default:
2080             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2081             break;
2082       }
2083       if(ret == RFAILED)
2084          break;
2085    }
2086
2087    if(ret == ROK)
2088    {
2089       ueCb->f1apMsgDb.dlRrcMsgCount++;
2090       rrcMsgType = setDlRRCMsgType(ueCb);
2091       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2092    }
2093    return ret;
2094 }
2095
2096 /*******************************************************************
2097  *
2098  * @brief Builds Nrcgi
2099  *
2100  * @details
2101  *
2102  *    Function : BuildNrcgi
2103  *
2104  *    Functionality: Building the PLMN ID and NR Cell id
2105  *
2106  * @params[in] NRCGI_t *nrcgi
2107  * @return ROK     - success
2108  *         RFAILED - failure
2109  *
2110  * ****************************************************************/
2111 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2112 {
2113    uint8_t ret;
2114    uint8_t unused_bits = 4;
2115    uint8_t byteSize = 5;
2116
2117    /* Allocate Buffer Memory */
2118    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2119    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2120    if(nrcgi->pLMN_Identity.buf == NULLP)
2121    {
2122       return RFAILED;
2123    }
2124    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2125
2126    if(ret != ROK)
2127    {
2128       return RFAILED;
2129    }
2130    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2131    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2132    if(nrcgi->nRCellIdentity.buf == NULLP)
2133    {
2134       return RFAILED;
2135    }
2136    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2137
2138    return ROK;
2139 }
2140 /*******************************************************************
2141  *
2142  * @brief Builds Special cell list for UE Setup Request
2143  *
2144  * @details
2145  *
2146  *    Function : BuildSplCellList
2147  *
2148  *    Functionality: Constructs the Special Cell list for UESetReq
2149  *
2150  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2151  *
2152  * @return ROK     - success
2153  *         RFAILED - failure
2154  *
2155  * ****************************************************************/
2156 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2157 {
2158    uint8_t  cellCnt;
2159    uint8_t  idx;
2160    uint8_t  ret;
2161    cellCnt = 1;
2162    spCellLst->list.count = cellCnt;
2163    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2164    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2165    if(spCellLst->list.array == NULLP)
2166    {
2167       return RFAILED;
2168    }
2169    for(idx=0; idx<cellCnt; idx++)
2170    {
2171       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2172       if(spCellLst->list.array[idx] == NULLP)
2173       {
2174          return RFAILED;
2175       }
2176    }
2177    idx = 0;
2178    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2179    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2180    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2181
2182    /* Special Cell ID -NRCGI */
2183    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2184    if(ret != ROK)
2185    {
2186       return RFAILED;
2187    }
2188    /*Special Cell Index*/
2189    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2190    return ROK;
2191 }/* End of BuildSplCellList*/
2192
2193 /*******************************************************************
2194  *
2195  * @brief Builds SRBS to be setup
2196  *
2197  * @details
2198  *
2199  *    Function : BuildSRBSetup
2200  *
2201  *    Functionality: Constructs the SRB's for UESetReq
2202  *
2203  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2204  *
2205  * @return ROK     - success
2206  *         RFAILED - failure
2207  *
2208  * ****************************************************************/
2209 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2210 {
2211    uint8_t idx;
2212    uint8_t srbCnt;
2213
2214    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2215       srbCnt = ueCb->numSrb;
2216    else
2217       srbCnt = 1;
2218    srbSet->list.count = srbCnt;
2219    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2220    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2221    if(srbSet->list.array == NULLP)
2222    {
2223       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2224       return RFAILED;
2225    }
2226
2227    for(idx=0; idx<srbCnt; idx++)
2228    {
2229       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2230       if(srbSet->list.array[idx] == NULLP)
2231       {
2232          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2233          return RFAILED;
2234       }
2235    }
2236
2237    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2238    {
2239       idx = 0;
2240       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2241       srbSet->list.array[idx]->criticality = Criticality_ignore;
2242       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2243       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2244       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2245       ueCb->numSrb++;
2246    }
2247    else
2248    {
2249       for(idx=0; idx<srbCnt; idx++)
2250       {
2251          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2252          srbSet->list.array[idx]->criticality = Criticality_ignore;
2253          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2254          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2255       }
2256    }
2257    return ROK;
2258 }/* End of BuildSRBSetup*/
2259
2260 /*******************************************************************
2261  *
2262  * @brief Builds QOS Info for DRB Setum Item
2263  *
2264  * @details
2265  *
2266  *    Function : BuildQOSInfo
2267  *
2268  *    Functionality: Constructs the QOS Info for DRB Setup Item
2269  *
2270  * @params[in] QoSInformation_t *qosinfo
2271  *             int16_t pduSessionID
2272  *
2273  * @return ROK     - success
2274  *         RFAILED - failure
2275  *
2276  * ****************************************************************/
2277 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2278 {
2279    uint8_t elementCnt = 0, qosCntIdx = 0;
2280    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2281
2282    /* NonDynamic5QIDescriptor */
2283    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2284    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2285    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2286    {
2287       return RFAILED;
2288    }
2289
2290    if(hoInProgress)
2291       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2292    else
2293    {
2294       /*FiveQI*/
2295       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2296          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2297       else
2298          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2299
2300       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2301    }
2302
2303    if(!hoInProgress)
2304    {
2305       /*AveragingWindow*/
2306       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2307       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2308       {
2309          return RFAILED;
2310       }
2311       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2312       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2313
2314       /*MaxDataBurstVolume*/
2315       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2316       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2317       {
2318          return RFAILED;
2319       }
2320       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2321       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2322    }
2323
2324    /*nRGRAN Allocation Retention Priority*/
2325    if(hoInProgress)
2326    {
2327       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2328       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2329       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2330    }
2331    else
2332    {
2333       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2334       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2335       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2336
2337       qosInfo->priorityLevel = PriorityLevel_lowest;
2338       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2339       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2340    }
2341
2342    /* PDU session ID */
2343    if(!hoInProgress)
2344    {
2345       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2346       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2347       {
2348          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2349          return ROK;
2350       }
2351
2352       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2353       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2354
2355       if(qosIeExt)
2356       {
2357          elementCnt = NUM_QOS_EXT;
2358          qosIeExt->list.count = elementCnt;
2359          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2360
2361          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2362          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2363
2364          if(qosIeExt->list.array == NULLP)
2365          {
2366             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2367             return  RFAILED;
2368          }
2369
2370          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2371          {
2372             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2373             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2374             {
2375                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2376                return  RFAILED;
2377             }
2378             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2379             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2380             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2381             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2382             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2383                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2384             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2385             qosInfo->pduSessionId = pduSessionID;
2386          }
2387       }
2388       else
2389       {
2390          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2391          return RFAILED;
2392       }
2393    }
2394    return ROK;
2395 }/*End of BuildQOSInfo*/
2396
2397 /*******************************************************************
2398  *
2399  * @brief Builds SNSSAI
2400  *
2401  * @details
2402  *
2403  *    Function : BuildSNSSAI
2404  *
2405  *    Functionality: Constructs the SNSSAI For DRB list
2406  *
2407  * @params[in] SNSSAI_t *snssai
2408  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2409  *
2410  * @return ROK     - success
2411  *         RFAILED - failure
2412  *
2413  * ****************************************************************/
2414 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2415 {
2416    /*SNSSAI*/
2417    /*ssT*/
2418    snssai->sST.size = sizeof(uint8_t);
2419    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2420    if(snssai->sST.buf == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    if(!hoInProgress)
2425       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2426    else
2427       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2428
2429    /*sD*/
2430    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2431    if(snssai->sD == NULLP)
2432    {
2433       return RFAILED;
2434    }
2435    snssai->sD->size = 3 * sizeof(uint8_t);
2436    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2437    if(snssai->sD->buf == NULLP)
2438    {
2439       return RFAILED;
2440    }
2441    if(!hoInProgress)
2442       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2443    else
2444       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2445
2446    if(!hoInProgress)
2447       drbInfo->snssai = snssaiToCopy;
2448    return ROK;
2449 }/*End of BuildSNSSAI*/
2450
2451 /*******************************************************************
2452  *
2453  * @brief Builds the flow map.
2454  *
2455  * @details
2456  *
2457  *    Function : BuildFlowsMap
2458  *
2459  *    Functionality: Constructs the flowmap For DRB list
2460  *
2461  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2462  *
2463  * @return ROK     - success
2464  *         RFAILED - failure
2465  *
2466  * ****************************************************************/
2467 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2468 {
2469    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2470    FlowsMapped *qosFlow;
2471
2472    if(!hoInProgress)
2473       flowCnt = 1;
2474    else
2475       flowCnt = drbInfo->numFlowMap;
2476    flowMap->list.count = flowCnt;
2477    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2478    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2479    if(flowMap->list.array == NULLP)
2480    {
2481       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2482       return RFAILED;
2483    }
2484    for(idx=0; idx<flowCnt; idx++)
2485    {
2486       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2487       if(flowMap->list.array[idx] == NULLP)
2488       {
2489          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2490          return RFAILED;
2491       }
2492
2493       if(!hoInProgress)
2494       {
2495          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2496          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2497          {
2498             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2499             {
2500                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2501                {
2502                   qosFlow = &drbInfo->flowMapList[flowIdx];
2503                   break;
2504                }
2505             }
2506          }
2507          else
2508          {
2509             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2510             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2511          }
2512       }
2513       else
2514       {
2515          qosFlow = &drbInfo->flowMapList[idx];
2516          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2517       }
2518
2519       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2520             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2521       if(ret != ROK)
2522       {
2523          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2524          return RFAILED;
2525       }
2526
2527       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2528          drbInfo->numFlowMap++;
2529    }
2530    return ROK;
2531 }/*End of BuildFlowsMap*/
2532
2533 /*******************************************************************
2534  *
2535  * @brief Builds the Uplink Tunnel Info
2536  *
2537  * @details
2538  *
2539  *    Function : BuildULTnlInfo
2540  *
2541  *    Functionality: Constructs the UL TnlInfo For DRB list
2542  *
2543  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2544  *
2545  * @return ROK     - success
2546  *         RFAILED - failure
2547  *
2548  * ****************************************************************/
2549 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2550 {
2551    uint8_t idx;
2552    uint8_t ulCnt;
2553
2554    ulCnt = 1;
2555    ulInfo->list.count = ulCnt;
2556    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2557    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2558    if(ulInfo->list.array == NULLP)
2559    {
2560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2561       return RFAILED;
2562    }
2563    for(idx=0; idx<ulCnt; idx++)
2564    {
2565       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2566       if(ulInfo->list.array[idx] == NULLP)
2567       {
2568          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2569               return RFAILED;
2570       }
2571    }
2572    idx = 0;
2573    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2574    /*GTP TUNNEL*/
2575    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2576    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2577    {
2578       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2579       return RFAILED;
2580    }
2581    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2582    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2583       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2584    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2585    {
2586       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2587       return RFAILED;
2588    }
2589
2590    if(!hoInProgress)
2591    {
2592       /* NOTE: Below IP address must be changed if running on different IP configuration */
2593       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2594       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2595       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2596       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2597       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2598
2599       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2600       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2601       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2602       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2603    }
2604    else
2605    {
2606       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2607       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2608       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2609       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2610       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2611    }
2612
2613    /*GTP TEID*/
2614    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2615    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2616       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2617    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2618    {
2619       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2620       return RFAILED;
2621    }
2622
2623    if(!hoInProgress)
2624    {
2625       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2626       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2627       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2628       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2629
2630       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2631       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2632       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2633       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2634    }
2635    else
2636    {
2637       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2638       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2639       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2640       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2641    }
2642    return ROK;
2643 }/*End of BuildULTnlInfo*/
2644
2645 /*******************************************************************
2646  *
2647  * @brief Builds DRBS to be setup
2648  *
2649  * @details
2650  *
2651  *    Function : BuildDRBSetup
2652  *
2653  *    Functionality: Constructs the DRB's for UESetReq
2654  *
2655  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2656  *
2657  * @return ROK     - success
2658  *         RFAILED - failure
2659  *
2660  * ****************************************************************/
2661 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2662 {
2663    uint16_t snssaiIdx=0;
2664    uint8_t idx = 0, extIeIdx = 0;
2665    uint8_t elementCnt = 0, drbCnt = 0;
2666    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2667    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2668    DRBs_ToBeSetup_Item_t *drbSetItem;
2669    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2670    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2671
2672    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2673       drbCnt = ueCb->numDrb;
2674    else
2675       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2676    drbSet->list.count = drbCnt;
2677
2678    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2679    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2680    if(drbSet->list.array == NULLP)
2681    {
2682       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2683       return RFAILED;
2684    }
2685
2686    for(idx=0; idx<drbCnt; idx++)
2687    {
2688       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2689       if(drbSet->list.array[idx] == NULLP)
2690       {
2691          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2692          return RFAILED;
2693       }
2694
2695       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2696       drbSet->list.array[idx]->criticality = Criticality_ignore;
2697       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2698       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2699       /*dRBID*/
2700       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2701       {
2702          drbSetItem->dRBID = idx + 1;
2703          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2704       }
2705       else
2706          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2707
2708       /*qoSInformation*/
2709       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2710       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2711       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2712       {
2713          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2714          return RFAILED;
2715       }
2716       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2717       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2718       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2719       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2720          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2721                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2722       else
2723          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2724                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2725       if(BuildQOSInforet != ROK)
2726       {
2727          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2728          return RFAILED;
2729       }
2730
2731       /*SNSSAI*/
2732       snssaiIdx = (idx% cuCb.numSnssaiSupported);
2733       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2734          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2735                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
2736       else
2737          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2738                choice_extension->value.choice.DRB_Information.sNSSAI, NULLP, TRUE);
2739       if(BuildSNSSAIret != ROK)
2740       {
2741          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2742          return RFAILED;
2743       }
2744
2745       /*Flows mapped to DRB List*/
2746       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2747          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2748                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2749       else
2750          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2751                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2752       if(BuildFlowsMapret != ROK)
2753       {
2754          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2755          return RFAILED;
2756       }
2757
2758       /*ULUPTNLInformation To Be Setup List*/
2759       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2760          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2761                FALSE);
2762       else
2763          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2764                TRUE);
2765       if(BuildULTnlInforet != ROK)
2766       {
2767          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2768          return RFAILED;
2769       }
2770
2771       /*RLCMode*/
2772       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2773       {
2774          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2775          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2776       }
2777       else
2778          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2779
2780       /* DL PDCP SN Length */
2781       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2782       {
2783          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2784          if(!drbToBeSetupExt)
2785          {
2786             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2787             return RFAILED;
2788          }
2789
2790          elementCnt = 1;
2791          drbToBeSetupExt->list.count = elementCnt;
2792          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
2793
2794          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
2795          if(!drbToBeSetupExt->list.array)
2796          {
2797              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
2798              return RFAILED;
2799          }
2800
2801          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
2802          {
2803             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
2804             if(!drbToBeSetupExt->list.array[extIeIdx])
2805             {
2806                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
2807                return RFAILED;
2808             }
2809          }
2810
2811          extIeIdx = 0;
2812          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
2813
2814          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
2815          drbToBeSetupExtIe->criticality = Criticality_ignore;
2816          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
2817          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
2818          drbSetItem->iE_Extensions = drbToBeSetupExt;
2819       }
2820
2821       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2822          ueCb->numDrb++;
2823    }
2824    return ROK;
2825 }/* End of BuildDRBSetup*/
2826
2827 /*******************************************************************
2828  *
2829  * @brief Deallocating memory of function BuildAndSendUESetReq
2830  *
2831  * @details
2832  *
2833  *    Function : FreeNrcgi
2834  *
2835  *    Functionality: Deallocating memory for function BuildNrcgi
2836  *
2837  * @params[in] NRCGI_t *nrcgi
2838  *
2839  * @return void
2840  *
2841  *******************************************************************/
2842 void FreeNrcgi(NRCGI_t *nrcgi)
2843 {
2844    if(nrcgi->pLMN_Identity.buf != NULLP)
2845    {
2846       if(nrcgi->nRCellIdentity.buf != NULLP)
2847       {
2848          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2849       }
2850       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2851    }
2852 }
2853 /*******************************************************************
2854  *
2855  * @brief  Deallocating memory of function BuildAndSendUESetReq
2856  *
2857  * @details
2858  *
2859  *    Function : FreeSplCellList
2860  *
2861  *    Functionality: Deallocating memory for function BuildSplCellList
2862  *
2863  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2864  *
2865  * @return void
2866  *
2867  *
2868  * *****************************************************************/
2869 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2870 {
2871    uint8_t  cellidx;
2872    if(spCellLst->list.array != NULLP)
2873    {
2874       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2875       {
2876          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2877          {
2878             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2879          }
2880          if(spCellLst->list.array[cellidx]!=NULLP)
2881          {
2882             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2883          }
2884       }
2885       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2886    }
2887 }
2888 /*******************************************************************
2889  *
2890  * @brief Deallocating memory of function BuildAndSendUESetReq
2891  *
2892  * @details
2893  *
2894  *    Function : FreeSRBSetup
2895  *
2896  *    Functionality: Deallocating memory for function BuildSRBSetup
2897  *
2898  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2899  *
2900  * @return void
2901  *
2902  *
2903  * ******************************************************************/
2904 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2905 {
2906    uint8_t srbidx;
2907    if(srbSet->list.array != NULLP)
2908    {
2909       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2910       {
2911          if(srbSet->list.array[srbidx]!=NULLP)
2912          {
2913             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2914          }
2915       }
2916       CU_FREE(srbSet->list.array,srbSet->list.size);
2917    }
2918 }
2919 /*******************************************************************
2920  *
2921  * @brief Deallocating memory of function BuildAndSendUESetReq
2922  *
2923  * @details
2924  *
2925  *    Function : FreeQOSInfo
2926  *
2927  *    Functionality:  Deallocating memory for function BuildQOSInfo
2928  *
2929  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2930  *
2931  * @return void
2932  *
2933  * ****************************************************************/
2934 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2935 {
2936    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2937    uint8_t qosCntIdx = 0;
2938
2939    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2940    {
2941       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2942       {
2943          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2944          {
2945             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2946                   sizeof(MaxDataBurstVolume_t));
2947          }
2948          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2949                sizeof(AveragingWindow_t));
2950       }
2951       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2952             sizeof(NonDynamic5QIDescriptor_t));
2953    }
2954    if(drbQos->iE_Extensions)
2955    {
2956       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2957       if(qosIeExt->list.array != NULLP)
2958       {
2959          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2960          {
2961             if(qosIeExt->list.array[qosCntIdx])
2962             {
2963                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2964             }
2965          }
2966          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2967       }
2968
2969       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2970    }
2971 }
2972 /*******************************************************************
2973  *
2974  * @brief Deallocating memory of function BuildAndSendUESetReq
2975  *
2976  * @details
2977  *
2978  *    Function : FreeULTnlInfo
2979  *
2980  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2981  *
2982  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2983  *
2984  * @return void
2985  *
2986
2987  * ****************************************************************/
2988 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2989 {
2990    uint8_t ulidx=0;
2991    if(ulInfo->list.array != NULLP)
2992    {
2993       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2994       {
2995          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2996          {
2997             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2998             {
2999                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3000                      transportLayerAddress.buf != NULLP)
3001                {
3002                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3003                         !=NULLP)
3004                   {
3005                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3006                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3007                            gTPTunnel->gTP_TEID.size);
3008                   }
3009                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3010                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3011                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3012                }
3013                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3014                      sizeof(GTPTunnel_t));
3015             }
3016          }
3017          if(ulInfo->list.array[ulidx]!=NULLP)
3018          {
3019             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3020          }
3021       }
3022       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3023    }
3024 }
3025 /*******************************************************************
3026  *
3027  * @brief Deallocating memory for BuildAndSendUESetReq
3028  *
3029  * @details
3030  *
3031  *    Function : FreeDRBSetup
3032  *
3033  *    Functionality:  Deallocating memory for BuildDRBSetup
3034  *
3035  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3036  *
3037  * @return void
3038  *
3039  * ****************************************************************/
3040 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3041 {
3042    DRBs_ToBeSetup_Item_t *drbSetItem;
3043    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3044
3045    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3046
3047    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3048    if(drbSet->list.array != NULLP)
3049    {
3050       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3051       {
3052               if(drbSet->list.array[drbidx] != NULLP)
3053               {
3054                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3055                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3056                  {
3057                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3058                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3059                {
3060                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3061                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3062                             {
3063                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3064                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3065                                {
3066                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3067                                        {
3068                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3069                                           {
3070                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3071                                              {
3072                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3073                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3074                                                      {
3075                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3076                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3077                                                          {
3078                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3079                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3080                                                              {
3081                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3082                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3083                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3084                                                                      {
3085                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3086                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3087                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3088                                                                          {
3089                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3090                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3091                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3092                                                                                   {
3093                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3094                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3095
3096                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3097                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3098                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3099                                                                                                    sizeof(MaxDataBurstVolume_t));
3100                                                                                   }
3101                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3102                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3103                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3104                                                                          }
3105                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3106                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3107                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3108                                                                      }
3109                                                             }
3110                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3111                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3112                                                             {
3113                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3114                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3115                                                             }
3116                                                         }
3117                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3118                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3119                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3120                                                      }
3121                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3122                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3123                                             }
3124                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3125                                                               sizeof(OCTET_STRING_t));
3126                                        }
3127                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3128                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3129                                     }
3130                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3131                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3132                             }
3133                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3134                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3135                          }
3136                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3137                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3138              }
3139              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3140                         iE_Extensions != NULLP)
3141              {
3142                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3143                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3144                  if(qosIeExt->list.array != NULLP)
3145                  {
3146                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3147                    {
3148                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3149                       {
3150                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3151                       }
3152                     }
3153                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3154                   }
3155                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3156                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3157               }
3158
3159                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3160                 }
3161                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3162               }
3163       }
3164       CU_FREE(drbSet->list.array,drbSet->list.size);
3165    }
3166 }
3167
3168
3169 /*******************************************************************
3170  *
3171  * @brief Free the UE Setup Request
3172  *
3173  * @details
3174  *
3175  *    Function : FreeUeContextSetupReq
3176  *
3177  *    Functionality: Deallocate the memory of BuildUESetReq
3178  *
3179  * @params[in]  F1AP_PDU_t  *f1apMsg
3180  *
3181  * @return void
3182  *
3183  *
3184  * ****************************************************************/
3185 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3186 {
3187    uint8_t idx, ieId;
3188    UEContextSetupRequest_t  *ueSetReq = NULLP;
3189
3190    if(f1apMsg != NULLP)
3191    {
3192       if(f1apMsg->choice.initiatingMessage != NULLP)
3193       {
3194          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3195          if(ueSetReq->protocolIEs.list.array != NULLP)
3196          {
3197             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3198             {
3199                if(ueSetReq->protocolIEs.list.array[idx])
3200                {
3201                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3202                   {
3203                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3204                         break;
3205                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3206                         break;
3207                      case ProtocolIE_ID_id_SpCell_ID:
3208                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3209                         break;
3210                      case ProtocolIE_ID_id_ServCellIndex:
3211                         break;
3212                      case ProtocolIE_ID_id_SpCellULConfigured:
3213                         break;
3214                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3215                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3216                         break;
3217                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3218                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3219                         break;
3220                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3221                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3222                         break;
3223                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3224                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3225                         break;
3226                      case ProtocolIE_ID_id_RRCContainer:
3227                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3228                         {
3229                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3230                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3231                         }
3232                         break;
3233                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3234                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3235                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3236                         break;
3237                      default:
3238                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3239                         break;
3240                   }
3241                }
3242                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3243             }
3244             for(ieId=0; ieId<idx; ieId++)
3245             {
3246                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3247                {
3248                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3249                }
3250             }
3251             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3252          }
3253          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3254       }
3255       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3256    }
3257 }
3258
3259 /**Filling cell group info **/
3260 /*******************************************************************
3261  *
3262  * @brief Build Control resource set to add/modify list
3263  *
3264  * @details
3265  *
3266  *    Function : BuildControlRSetToAddModList
3267  *
3268  *    Functionality: Build Control resource set to add/modify list
3269  *
3270  * @params[in]
3271  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3272  *
3273  * @return ROK     - success
3274  *         RFAILED - failure
3275  *
3276  * ****************************************************************/
3277    uint8_t BuildControlRSetToAddModList
3278 (
3279  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3280  )
3281 {
3282    uint8_t idx;
3283    uint8_t elementCnt;
3284    uint8_t numBytes, bitsUnused;
3285    struct ControlResourceSet *controlRSet;
3286    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3287    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3288
3289    elementCnt = 1;
3290    controlRSetList->list.count = elementCnt;
3291    controlRSetList->list.size = \
3292                                 elementCnt * sizeof(struct ControlResourceSet *);
3293
3294    controlRSetList->list.array = NULLP;
3295    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3296    if(!controlRSetList->list.array)
3297    {
3298       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3299       return RFAILED;
3300    }
3301
3302    for(idx = 0; idx < elementCnt; idx++)
3303    {
3304       controlRSetList->list.array[idx] = NULLP;
3305       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3306       if(!controlRSetList->list.array[idx])
3307       {
3308          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3309          return RFAILED;
3310       }
3311    }
3312
3313    idx=0;
3314    controlRSet = controlRSetList->list.array[idx];
3315    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3316
3317    /* Values harcoded according to our design:
3318     * size 6 bytes
3319     * 3 LSBs unsued
3320     * Bit string stored ff0000000000
3321     */
3322    numBytes = 6;
3323    bitsUnused = 3;
3324    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3325    controlRSet->frequencyDomainResources.buf = NULLP;
3326    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3327          controlRSet->frequencyDomainResources.size);
3328    if(!controlRSet->frequencyDomainResources.buf)
3329    {
3330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3331       return RFAILED;
3332    }
3333
3334    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3335    coreset0EndPrb = CORESET0_END_PRB;
3336    coreset1StartPrb = coreset0EndPrb + 6;
3337    coreset1NumPrb = CORESET1_NUM_PRB;
3338    /* calculate the PRBs */
3339    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3340    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3341    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3342
3343    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3344    controlRSet->cce_REG_MappingType.present = \
3345                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3346
3347    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3348    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3349    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3350    controlRSet->tci_PresentInDCI = NULLP;
3351 #if 0
3352    uint8_t tciStateIdx;
3353
3354    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3355          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3356    if(!controlRset->tci_StatesPDCCH_ToAddList)
3357    {
3358       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3359       return RFAILED;
3360    }
3361
3362    elementCnt = 1;
3363    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3364    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3365    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3366          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3367       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3368       {
3369          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3370          return RFAILED;
3371       }
3372
3373    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3374    {
3375       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3376       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3377       {
3378          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3379          return RFAILED;
3380       }
3381    }
3382
3383    tciStateIdx = 0;
3384    /* TODO */
3385    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3386
3387    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3388    if(!controlRset->tci_PresentInDCI)
3389    {
3390       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3391       return RFAILED;
3392    }
3393    /* TODO */
3394    *(controlRset->tci_PresentInDCI);
3395 #endif
3396
3397    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3398    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3399    if(!controlRSet->pdcch_DMRS_ScramblingID)
3400    {
3401       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3402       return RFAILED;
3403    }
3404    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3405
3406    return ROK;
3407 } /* End BuildControlRSetToAddModList */
3408
3409 /*******************************************************************
3410  *
3411  * @brief Build search space to add/modify list
3412  *
3413  * @details
3414  *
3415  *    Function : BuildSearchSpcToAddModList
3416  *
3417  *    Functionality: Build search space to add/modify list
3418  *
3419  * @params[in]
3420  * @return ROK     - success
3421  *         RFAILED - failure
3422  *
3423  * ****************************************************************/
3424    uint8_t BuildSearchSpcToAddModList
3425 (
3426  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3427  )
3428 {
3429    uint8_t idx;
3430    uint8_t numBytes;
3431    uint8_t byteIdx;
3432    uint8_t bitsUnused;
3433    uint8_t elementCnt;
3434    struct SearchSpace *searchSpc;
3435
3436    elementCnt = 1;
3437    searchSpcList->list.count = elementCnt;
3438    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3439
3440    searchSpcList->list.array = NULLP;
3441    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3442    if(!searchSpcList->list.array)
3443    {
3444       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3445       return RFAILED;
3446    }
3447
3448    for(idx = 0; idx < elementCnt; idx++)
3449    {
3450       searchSpcList->list.array[idx] = NULLP;
3451       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3452       if(!searchSpcList->list.array[idx])
3453       {
3454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3455          return RFAILED;
3456       }
3457    }
3458
3459    idx = 0;
3460    searchSpc = searchSpcList->list.array[idx];
3461
3462    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3463
3464    searchSpc->controlResourceSetId = NULLP;
3465    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3466    if(!searchSpc->controlResourceSetId)
3467    {
3468       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3469       return RFAILED;
3470    }
3471    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3472
3473    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3474    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3475          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3476    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3477    {
3478       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3479       return RFAILED;
3480    }
3481    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3482                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3483
3484    searchSpc->duration = NULLP;
3485    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3486    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3487    if(!searchSpc->monitoringSymbolsWithinSlot)
3488    {
3489       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3490       return RFAILED;
3491    }
3492
3493    /* Values taken from reference logs :
3494     * size 2 bytes
3495     * 2 LSBs unsued
3496     * Bit string stores 8000
3497     */
3498    numBytes = 2;
3499    bitsUnused = 2;
3500
3501    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3502    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3503    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3504          searchSpc->monitoringSymbolsWithinSlot->size);
3505    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3506    {
3507       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3508       return RFAILED;
3509    }
3510
3511    byteIdx = 0;
3512    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3513                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3514    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3515    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3516
3517    searchSpc->nrofCandidates = NULLP;
3518    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3519    if(!searchSpc->nrofCandidates)
3520    {
3521       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3522       return RFAILED;
3523    }
3524
3525    searchSpc->nrofCandidates->aggregationLevel1 = \
3526                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3527    searchSpc->nrofCandidates->aggregationLevel2 = \
3528                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3529    searchSpc->nrofCandidates->aggregationLevel4 = \
3530                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3531    searchSpc->nrofCandidates->aggregationLevel8 = \
3532                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3533    searchSpc->nrofCandidates->aggregationLevel16 = \
3534                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3535
3536    searchSpc->searchSpaceType = NULLP;
3537    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3538    if(!searchSpc->searchSpaceType)
3539    {
3540       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3541       return RFAILED;
3542    }
3543
3544    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3545
3546    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3547    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3548          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3549    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3550    {
3551       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3552       return RFAILED;
3553    }
3554    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3555                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3556
3557    return ROK;
3558 }/* End BuildSearchSpcToAddModList */
3559
3560 /*******************************************************************
3561  *
3562  * @brief Builds BWP DL dedicated PDCCH config
3563  *
3564  * @details
3565  *
3566  *    Function : BuildBWPDlDedPdcchCfg
3567  *
3568  *    Functionality: Builds BWP DL dedicated PDCCH config
3569  *
3570  * @params[in] struct PDCCH_Config *pdcchCfg
3571  *
3572  * @return ROK     - success
3573  *         RFAILED - failure
3574  *
3575  * ****************************************************************/
3576 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3577 {
3578    pdcchCfg->controlResourceSetToAddModList = NULLP;
3579    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3580          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3581    if(!pdcchCfg->controlResourceSetToAddModList)
3582    {
3583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3584       return RFAILED;
3585    }
3586
3587    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3588    {
3589       return RFAILED;
3590    }
3591
3592    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3593
3594    pdcchCfg->searchSpacesToAddModList = NULLP;
3595    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3596          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3597    if(!pdcchCfg->searchSpacesToAddModList)
3598    {
3599       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3600       return RFAILED;
3601    }
3602
3603    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3604    {
3605       return RFAILED;
3606    }
3607
3608    pdcchCfg->searchSpacesToReleaseList = NULLP;
3609    pdcchCfg->downlinkPreemption = NULLP;
3610    pdcchCfg->tpc_PUSCH = NULLP;
3611    pdcchCfg->tpc_PUCCH = NULLP;
3612    pdcchCfg->tpc_SRS = NULLP;
3613
3614    return ROK;
3615 }
3616
3617 /*******************************************************************
3618  *
3619  * @brief Builds DMRS DL PDSCH Mapping type A
3620  *
3621  * @details
3622  *
3623  *    Function : BuildDMRSDLPdschMapTypeA
3624  *
3625  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3626  *
3627  * @params[in]
3628  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3629  * @return ROK     - success
3630  *         RFAILED - failure
3631  *
3632  * ****************************************************************/
3633    uint8_t BuildDMRSDLPdschMapTypeA
3634 (
3635  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3636  )
3637 {
3638    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3639    dmrsDlCfg->choice.setup = NULLP;
3640    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3641    if(!dmrsDlCfg->choice.setup)
3642    {
3643       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3644       return RFAILED;
3645    }
3646
3647    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3648    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3649    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3650    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3651    {
3652       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3653       return RFAILED;
3654    }
3655    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3656
3657    dmrsDlCfg->choice.setup->maxLength = NULLP;
3658    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3659    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3660    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3661
3662    return ROK;
3663 }
3664
3665 /*******************************************************************
3666  *
3667  * @brief Builds TCI states to add/modify list
3668  *
3669  * @details
3670  *
3671  *    Function : BuildTCIStatesToAddModList
3672  *
3673  *    Functionality:Builds TCI states to add/modify list
3674  *
3675  * @params[in]
3676  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3677  *
3678  * @return ROK     - success
3679  *         RFAILED - failure
3680  *
3681  * ****************************************************************/
3682 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3683 {
3684    return ROK;
3685 }
3686
3687 /*******************************************************************
3688  *
3689  * @brief Builds PDSCH time domain allocation list
3690  *
3691  * @details
3692  *
3693  *    Function : BuildPdschTimeDomAllocList
3694  *
3695  *    Functionality: Builds PDSCH time domain allocation list
3696  *
3697  * @params[in]
3698  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3699  *
3700  * @return ROK     - success
3701  *         RFAILED - failure
3702  *
3703  * ****************************************************************/
3704    uint8_t BuildPdschTimeDomAllocList
3705 (
3706  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3707  )
3708 {
3709    uint8_t idx;
3710    uint8_t elementCnt;
3711    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3712
3713    timeDomAllocList->present = \
3714                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3715
3716    timeDomAllocList->choice.setup = NULLP;
3717    CU_ALLOC(timeDomAllocList->choice.setup, \
3718          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3719    if(!timeDomAllocList->choice.setup)
3720    {
3721       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3722       return RFAILED;
3723    }
3724
3725    elementCnt = 2;
3726    timeDomAllocList->choice.setup->list.count = elementCnt;
3727    timeDomAllocList->choice.setup->list.size = \
3728                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3729
3730    timeDomAllocList->choice.setup->list.array = NULLP;
3731    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3732          timeDomAllocList->choice.setup->list.size);
3733    if(!timeDomAllocList->choice.setup->list.array)
3734    {
3735       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3736       return RFAILED;
3737    }
3738
3739    for(idx = 0; idx < elementCnt; idx++)
3740    {
3741       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3742       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3743             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3744       if(!timeDomAllocList->choice.setup->list.array[idx])
3745       {
3746          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3747          return RFAILED;
3748       }
3749    }
3750
3751    idx = 0;
3752    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3753    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3754    if(!timeDomAlloc->k0)
3755    {
3756        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3757        return RFAILED;
3758    }
3759    *(timeDomAlloc->k0) = 0;
3760    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3761    timeDomAlloc->startSymbolAndLength = 66;
3762
3763    idx++;
3764    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3765    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3766    if(!timeDomAlloc->k0)
3767    {
3768       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3769       return RFAILED;
3770    }
3771    *(timeDomAlloc->k0) = 1;
3772    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3773    timeDomAlloc->startSymbolAndLength = 66;
3774
3775    return ROK;
3776 }
3777
3778 /*******************************************************************
3779  *
3780  * @brief Builds PDSCH PRB Bundling type
3781  *
3782  * @details
3783  *
3784  *    Function : BuildPdschPrbBundlingType
3785  *
3786  *    Functionality: Builds PDSCH PRB Bundling type
3787  *
3788  * @params[in]
3789  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3790  *
3791  * @return ROK     - success
3792  *         RFAILED - failure
3793  *
3794  * ****************************************************************/
3795    uint8_t BuildPdschPrbBundlingType
3796 (
3797  struct PDSCH_Config__prb_BundlingType *prbBndlType
3798  )
3799 {
3800    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3801
3802    prbBndlType->choice.staticBundling = NULLP;
3803    CU_ALLOC(prbBndlType->choice.staticBundling, \
3804          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3805    if(!prbBndlType->choice.staticBundling)
3806    {
3807       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3808       return RFAILED;
3809    }
3810    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3811
3812    return ROK;
3813 }
3814
3815 /*******************************************************************
3816  *
3817  * @brief Builds BWP DL dedicated PDSCH config
3818  *
3819  * @details
3820  *
3821  *    Function : BuildBWPDlDedPdschCfg
3822  *
3823  *    Functionality: Builds BWP DL dedicated PDSCH config
3824  *
3825  * @params[in] struct PDSCH_Config *pdschCfg
3826  *
3827  * @return ROK     - success
3828  *         RFAILED - failure
3829  *
3830  * ****************************************************************/
3831 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3832 {
3833    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3834
3835    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3836    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3837          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3838    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3839    {
3840       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3841       return RFAILED;
3842    }
3843
3844    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3845    {
3846       return RFAILED;
3847    }
3848
3849    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3850    pdschCfg->tci_StatesToAddModList = NULLP;
3851    pdschCfg->tci_StatesToReleaseList = NULLP;
3852    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3853 #if 0
3854    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3855    if(!pdschCfg->tci_StatesToAddModList)
3856    {
3857       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3858       return RFAILED;
3859    }
3860    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3861    {
3862       return RFAILED;
3863    }
3864 #endif
3865
3866    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3867
3868    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3869    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3870          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3871    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3872    {
3873       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3874       return RFAILED;
3875    }
3876    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3877    {
3878       return RFAILED;
3879    }
3880    pdschCfg->pdsch_AggregationFactor = NULLP;
3881    pdschCfg->rateMatchPatternToAddModList = NULLP;
3882    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3883    pdschCfg->rateMatchPatternGroup1 = NULLP;
3884    pdschCfg->rateMatchPatternGroup2 = NULLP;
3885    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3886    pdschCfg->mcs_Table = NULLP;
3887
3888    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3889    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3890    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3891    {
3892       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3893       return RFAILED;
3894    }
3895    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3896
3897    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3898    {
3899       return RFAILED;
3900    }
3901
3902    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3903    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3904    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3905    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3906    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3907    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3908    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3909
3910    return ROK;
3911 }
3912
3913 /*******************************************************************
3914  *
3915  * @brief Builds intitial DL BWP
3916  * @details
3917  *
3918  *    Function : BuildInitialDlBWP
3919  *
3920  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3921  *
3922  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3923  *
3924  * @return ROK     - success
3925  *         RFAILED - failure
3926  *
3927  * ****************************************************************/
3928 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3929 {
3930    dlBwp->pdcch_Config = NULLP;
3931    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3932    if(!dlBwp->pdcch_Config)
3933    {
3934       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3935       return RFAILED;
3936    }
3937    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3938
3939    dlBwp->pdcch_Config->choice.setup = NULLP;
3940    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3941    if(!dlBwp->pdcch_Config->choice.setup)
3942    {
3943       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3944       return RFAILED;
3945    }
3946    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3947    {
3948       return RFAILED;
3949    }
3950
3951    dlBwp->pdsch_Config = NULLP;
3952    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3953    if(!dlBwp->pdsch_Config)
3954    {
3955       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3956       return RFAILED;
3957    }
3958    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3959
3960    dlBwp->pdsch_Config->choice.setup = NULLP;
3961    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3962    if(!dlBwp->pdsch_Config->choice.setup)
3963    {
3964       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3965       return RFAILED;
3966    }
3967
3968    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3969    {
3970       return RFAILED;
3971    }
3972
3973    dlBwp->sps_Config = NULLP;
3974    dlBwp->radioLinkMonitoringConfig = NULLP;
3975    return ROK;
3976 }
3977
3978 /*******************************************************************
3979  *
3980  * @brief Builds DMRS UL Pusch Mapping type A
3981  *
3982  * @details
3983  *
3984  *    Function : BuildDMRSULPuschMapTypeA
3985  *
3986  *    Functionality: Builds DMRS UL Pusch Mapping type A
3987  *
3988  * @params[in]
3989  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3990  * @return ROK     - success
3991  *         RFAILED - failure
3992  *
3993  * ****************************************************************/
3994    uint8_t BuildDMRSULPuschMapTypeA
3995 (
3996  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3997  )
3998 {
3999    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4000    dmrsUlCfg->choice.setup= NULLP;
4001    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4002    if(!dmrsUlCfg->choice.setup)
4003    {
4004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4005       return RFAILED;
4006    }
4007
4008    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4009    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4010    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4011    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4012    {
4013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4014       return RFAILED;
4015    }
4016    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4017
4018    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4019    dmrsUlCfg->choice.setup->maxLength = NULLP;
4020    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4021    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4022          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4023    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4024    {
4025       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4026       return RFAILED;
4027    }
4028
4029    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4030    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4031          sizeof(long));
4032    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4033    {
4034       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4035       return RFAILED;
4036    }
4037    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4038
4039    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4040    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4041    return ROK;
4042 }
4043
4044 /*******************************************************************
4045  *
4046  * @brief Build PUSCH time domain allocation list
4047  *
4048  * @details
4049  *
4050  *    Function : BuildPuschTimeDomAllocList
4051  *
4052  *    Functionality: Build PUSCH time domain allocation list
4053  *
4054  * @params[in]
4055  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4056  *
4057  * @return ROK     - success
4058  *         RFAILED - failure
4059  *
4060  * ****************************************************************/
4061    uint8_t BuildPuschTimeDomAllocList
4062 (
4063  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4064  )
4065 {
4066    uint8_t idx;
4067    uint8_t elementCnt;
4068    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4069
4070    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4071    timeDomAllocList->choice.setup = NULLP;
4072    CU_ALLOC(timeDomAllocList->choice.setup, \
4073          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4074    if(!timeDomAllocList->choice.setup)
4075    {
4076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4077       return RFAILED;
4078    }
4079
4080    elementCnt = 2;
4081    timeDomAllocList->choice.setup->list.count = elementCnt;
4082    timeDomAllocList->choice.setup->list.size = \
4083                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4084    timeDomAllocList->choice.setup->list.array = NULLP;
4085    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4086          timeDomAllocList->choice.setup->list.size);
4087    if(!timeDomAllocList->choice.setup->list.array)
4088    {
4089       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4090       return RFAILED;
4091    }
4092
4093    for(idx = 0; idx < elementCnt; idx++)
4094    {
4095       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4096       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4097             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4098       if(!timeDomAllocList->choice.setup->list.array[idx])
4099       {
4100          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4101          return RFAILED;
4102       }
4103    }
4104
4105    idx = 0;
4106    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4107    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4108    if(!timeDomAlloc->k2)
4109    {
4110       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4111       return RFAILED;
4112    }
4113    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4114    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4115    timeDomAlloc->startSymbolAndLength = 66;
4116
4117    idx++;
4118    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4119    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4120    if(!timeDomAlloc->k2)
4121    {
4122        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4123        return RFAILED;
4124    }
4125    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4126    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4127    timeDomAlloc->startSymbolAndLength = 66;
4128
4129    return ROK;
4130 }
4131
4132 /*******************************************************************
4133  *
4134  * @brief Builds BWP UL dedicated PUSCH Config
4135  *
4136  * @details
4137  *
4138  *    Function : BuildBWPUlDedPuschCfg
4139  *
4140  *    Functionality:
4141  *      Builds BWP UL dedicated PUSCH Config
4142  *
4143  * @params[in] : PUSCH_Config_t *puschCfg
4144  *
4145  * @return ROK     - success
4146  *         RFAILED - failure
4147  *
4148  * ****************************************************************/
4149 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4150 {
4151    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4152    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4153    if(!puschCfg->dataScramblingIdentityPUSCH)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4156       return RFAILED;
4157    }
4158    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4159
4160    puschCfg->txConfig = NULLP;
4161    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4162    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4163          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4164    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4165    {
4166       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4167       return RFAILED;
4168    }
4169
4170    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4171    {
4172       return RFAILED;
4173    }
4174
4175    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4176    puschCfg->pusch_PowerControl = NULLP;
4177    puschCfg->frequencyHopping = NULLP;
4178    puschCfg->frequencyHoppingOffsetLists = NULLP;
4179    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4180
4181    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4182    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4183          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4184    if(!puschCfg->pusch_TimeDomainAllocationList)
4185    {
4186       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4187       return RFAILED;
4188    }
4189
4190    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4191    {
4192       return RFAILED;
4193    }
4194
4195    puschCfg->pusch_AggregationFactor = NULLP;
4196    puschCfg->mcs_Table = NULLP;
4197    puschCfg->mcs_TableTransformPrecoder = NULLP;
4198    puschCfg->transformPrecoder = NULLP;
4199    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4200    if(!puschCfg->transformPrecoder)
4201    {
4202       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4203       return RFAILED;
4204    }
4205    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4206
4207    puschCfg->codebookSubset = NULLP;
4208    puschCfg->maxRank = NULLP;
4209    puschCfg->rbg_Size = NULLP;
4210    puschCfg->uci_OnPUSCH = NULLP;
4211    puschCfg->tp_pi2BPSK = NULLP;
4212
4213    return ROK;
4214 }
4215
4216 /*******************************************************************
4217  *
4218  * @brief Builds BWP UL dedicated PUCCH Config
4219  *
4220  * @details
4221  *
4222  *    Function : BuildBWPUlDedPucchCfg
4223  *
4224  *    Functionality:
4225  *      Builds BWP UL dedicated PUCCH Config
4226  *
4227  * @params[in] : PUCCH_Config_t *pucchCfg
4228  *
4229  * @return ROK     - success
4230  *         RFAILED - failure
4231  *
4232  * ****************************************************************/
4233 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4234 {
4235    uint8_t arrIdx, elementCnt;
4236    uint8_t rsrcIdx, rsrcSetIdx;
4237    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4238    PUCCH_Resource_t *rsrc = NULLP;
4239
4240    //RESOURCE SET
4241    elementCnt = 1;
4242    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4243    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4244    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4245    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4246    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4247    {
4248       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4249    }
4250    rsrcSetIdx = 0;
4251    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4252    rsrcSet->pucch_ResourceSetId = 1;
4253    elementCnt = 1;
4254    rsrcSet->resourceList.list.count = elementCnt;
4255    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4256    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4257    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4258    {
4259       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4260    }
4261    rsrcIdx = 0;
4262    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4263
4264    //RESOURCE
4265    elementCnt = 1;
4266    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4267    pucchCfg->resourceToAddModList->list.count = elementCnt;
4268    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4269    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4270    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4271    {
4272       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4273    }
4274    rsrcIdx = 0;
4275    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4276    rsrc->pucch_ResourceId = 1;
4277    rsrc->startingPRB = 0;
4278    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4279    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4280    rsrc->format.choice.format1->initialCyclicShift = 0;
4281    rsrc->format.choice.format1->nrofSymbols = 4;
4282    rsrc->format.choice.format1->startingSymbolIndex = 0;
4283    rsrc->format.choice.format1->timeDomainOCC = 0;
4284
4285    //PUCCH Format 1
4286    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4287    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4288    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4289    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4290    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4291
4292    //DL DATA TO UL ACK
4293    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4294    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4295    {
4296       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4297       return RFAILED;
4298    }
4299
4300    elementCnt = 2;
4301    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4302    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4303    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4304    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4305    {
4306       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4307       return RFAILED;
4308    }
4309
4310    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4311    {
4312       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4313       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4314       {
4315           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4316           return RFAILED;
4317       }
4318    }
4319
4320    arrIdx = 0;
4321    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4322    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4323
4324    return ROK;
4325 }
4326
4327 /*******************************************************************
4328  *
4329  * @brief Fills SRS resource to add/modify list
4330  *
4331  * @details
4332  *
4333  *    Function : BuildSrsRsrcAddModList
4334  *
4335  *    Functionality: Fills SRS resource to add/modify list
4336  *
4337  * @params[in]
4338  * @return ROK     - success
4339  *         RFAILED - failure
4340  *
4341  * ****************************************************************/
4342 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4343 {
4344    uint8_t   elementCnt;
4345    uint8_t   rsrcIdx;
4346
4347    elementCnt = 1;
4348    resourceList->list.count = elementCnt;
4349    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4350    resourceList->list.array = NULLP;
4351    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4352    if(!resourceList->list.array)
4353    {
4354       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4355       return RFAILED;
4356    }
4357
4358    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4359    {
4360       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4361       if(!resourceList->list.array[rsrcIdx])
4362       {
4363          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4364          return RFAILED;
4365       }
4366    }
4367
4368    rsrcIdx = 0;
4369    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4370    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4371    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4372
4373    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4374    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4375          sizeof(struct SRS_Resource__transmissionComb__n2));
4376    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4377    {
4378       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4379       return RFAILED;
4380    }
4381    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4382       = SRS_COMB_OFFSET_N2;
4383    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4384       = SRS_CYCLIC_SHIFT_N2;
4385
4386    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4387    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4388                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4389    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4390                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4391
4392    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4393    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4394    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4395    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4396    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4397    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4398                                                                SRS_Resource__groupOrSequenceHopping_neither;
4399
4400    /* Setting resource type to aperiodic for intergration purposes */
4401    resourceList->list.array[rsrcIdx]->resourceType.present = \
4402                                                              SRS_Resource__resourceType_PR_aperiodic;
4403    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4404    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4405          sizeof(struct SRS_Resource__resourceType__aperiodic));
4406    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4407    {
4408       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4409       return RFAILED;
4410    }
4411    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4412
4413    return ROK;
4414 }
4415
4416 /*******************************************************************
4417  *
4418  * @brief Build SRS resource set Add/mod list
4419  *
4420  * @details
4421  *
4422  *    Function : BuildSrsRsrcSetAddModList
4423  *
4424  *    Functionality: Build SRS resource set Add/mod list
4425  *
4426  * @params[in]
4427  * @return ROK     - success
4428  *         RFAILED - failure
4429  *
4430  * ****************************************************************/
4431    uint8_t BuildSrsRsrcSetAddModList
4432 (
4433  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4434  )
4435 {
4436    uint8_t  elementCnt;
4437    uint8_t  rSetIdx;
4438    uint8_t  rsrcIdx;
4439    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4440
4441    elementCnt = 1;
4442    rsrcSetList->list.count = elementCnt;
4443    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4444    rsrcSetList->list.array = NULLP;
4445    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4446    if(!rsrcSetList->list.array)
4447    {
4448       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4449       return RFAILED;
4450    }
4451
4452    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4453    {
4454       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4455       if(!rsrcSetList->list.array[rSetIdx])
4456       {
4457          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4458          return RFAILED;
4459       }
4460    }
4461
4462    rSetIdx = 0;
4463    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4464
4465    /* Fill Resource Id list in resource set */
4466    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4467    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4468          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4469    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4470    {
4471       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4472       return RFAILED;
4473    }
4474
4475    elementCnt = 1;
4476    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4477    rsrcIdList->list.count = elementCnt;
4478    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4479    rsrcIdList->list.array = NULLP;
4480    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4481    if(!rsrcIdList->list.array)
4482    {
4483       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4484       return RFAILED;
4485    }
4486
4487    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4488    {
4489       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4490       if(!rsrcIdList->list.array[rsrcIdx])
4491       {
4492          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4493          return RFAILED;
4494       }
4495    }
4496
4497    rsrcIdx = 0;
4498    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4499
4500    /* Fill resource type */
4501    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4502                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4503
4504    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4505    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4506          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4507    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4508    {
4509       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4510       return RFAILED;
4511    }
4512    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4513       = APERIODIC_SRS_RESRC_TRIGGER;
4514
4515    /* TODO : Fill values for below IEs as expected by Viavi */
4516    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4517    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4518
4519
4520    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4521    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4522    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4523    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4524    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4525
4526    return ROK;
4527 }
4528
4529 /*******************************************************************
4530  *
4531  * @brief Builds BWP UL dedicated SRS Config
4532  *
4533  * @details
4534  *
4535  *    Function : BuildBWPUlDedSrsCfg
4536  *
4537  *    Functionality: Builds BWP UL dedicated SRS Config
4538  *
4539  * @params[in] SRS Config
4540  * @return ROK     - success
4541  *         RFAILED - failure
4542  *
4543  * ****************************************************************/
4544 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4545 {
4546    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4547    srsCfg->srs_ResourceSetToAddModList = NULLP;
4548    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4549          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4550    if(!srsCfg->srs_ResourceSetToAddModList)
4551    {
4552       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4553       return RFAILED;
4554    }
4555    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4556    {
4557       return RFAILED;
4558    }
4559
4560    srsCfg->srs_ResourceToReleaseList = NULLP;
4561
4562    /* Resource to Add/Modify list */
4563    srsCfg->srs_ResourceToAddModList = NULLP;
4564    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4565          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4566    if(!srsCfg->srs_ResourceToAddModList)
4567    {
4568       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4569       return RFAILED;
4570    }
4571
4572    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4573    {
4574       return RFAILED;
4575    }
4576
4577    srsCfg->tpc_Accumulation = NULLP;
4578
4579    return ROK;
4580 }
4581
4582 /*******************************************************************
4583  *
4584  * @brief Builds inital UL BWP
4585  *
4586  * @details
4587  *
4588  *    Function : BuildInitialUlBWP
4589  *
4590  *    Functionality: Builds initial UL BWP
4591  *
4592  * @params[in] BWP_UplinkDedicated_t *ulBwp
4593  * @return ROK     - success
4594  *         RFAILED - failure
4595  *
4596  * ****************************************************************/
4597 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4598 {
4599    ulBwp->pucch_Config = NULLP;
4600    ulBwp->pucch_Config = NULLP;
4601    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4602    if(!ulBwp->pucch_Config)
4603    {
4604       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4605       return RFAILED;
4606    }
4607
4608    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4609    ulBwp->pucch_Config->choice.setup = NULLP;
4610    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4611    if(!ulBwp->pucch_Config->choice.setup)
4612    {
4613       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4614       return RFAILED;
4615    }
4616
4617    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4618    {
4619       return RFAILED;
4620    }
4621
4622    /* Fill BWP UL dedicated PUSCH config */
4623    ulBwp->pusch_Config = NULLP;
4624    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4625    if(!ulBwp->pusch_Config)
4626    {
4627       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4628       return RFAILED;
4629    }
4630
4631    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4632    ulBwp->pusch_Config->choice.setup = NULLP;
4633    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4634    if(!ulBwp->pusch_Config->choice.setup)
4635    {
4636       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4637       return RFAILED;
4638    }
4639
4640    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4641    {
4642       return RFAILED;
4643    }
4644
4645    ulBwp->configuredGrantConfig = NULLP;
4646
4647    /* Fill BPW UL dedicated SRS config */
4648    ulBwp->srs_Config = NULLP;
4649    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4650    if(!ulBwp->srs_Config)
4651    {
4652       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4653       return RFAILED;
4654    }
4655
4656    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4657    ulBwp->srs_Config->choice.setup = NULLP;
4658    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4659    if(!ulBwp->srs_Config->choice.setup)
4660    {
4661       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4662       return RFAILED;
4663    }
4664
4665    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4666    {
4667       return RFAILED;
4668    }
4669
4670    ulBwp->beamFailureRecoveryConfig = NULLP;
4671
4672    return ROK;
4673 }
4674
4675 /*******************************************************************
4676  *
4677  * @brief Builds Pusch Serving cell Config
4678  *
4679  * @details
4680  *
4681  *    Function : BuildPuschSrvCellCfg
4682  *
4683  *    Functionality: Builds Pusch Serving cell Config
4684  *
4685  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4686  *
4687  * @return ROK     - success
4688  *         RFAILED - failure
4689  *
4690  * ****************************************************************/
4691 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4692 {
4693    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4694    puschCfg->choice.setup = NULLP;
4695    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4696    if(!puschCfg->choice.setup)
4697    {
4698       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4699       return RFAILED;
4700    }
4701
4702    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4703    puschCfg->choice.setup->rateMatching = NULLP;
4704    puschCfg->choice.setup->xOverhead = NULLP;
4705    puschCfg->choice.setup->ext1 = NULLP;
4706    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4707    if(!puschCfg->choice.setup->ext1)
4708    {
4709       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4710       return RFAILED;
4711    }
4712
4713    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4714    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4715    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4716    {
4717       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4718       return RFAILED;
4719    }
4720    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4721
4722    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4723    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4724    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4725    {
4726       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4727       return RFAILED;
4728    }
4729    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4730    return ROK;
4731 }
4732
4733 /*******************************************************************
4734  *
4735  * @brief Builds UL config
4736  * @details
4737  *
4738  *    Function : BuildUlCfg
4739  *
4740  *    Functionality: Builds UL config in spCellCfgDed
4741  *
4742  * @params[in] UplinkConfig_t *ulCfg
4743  *
4744  * @return ROK     - success
4745  *         RFAILED - failure
4746  *
4747  * ****************************************************************/
4748 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4749 {
4750    ulCfg->initialUplinkBWP = NULLP;
4751    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4752    if(!ulCfg->initialUplinkBWP)
4753    {
4754       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4755       return RFAILED;
4756    }
4757
4758    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4759    {
4760       return RFAILED;
4761    }
4762
4763    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4764    ulCfg->uplinkBWP_ToAddModList = NULLP;
4765    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4766    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4767    if(!ulCfg->firstActiveUplinkBWP_Id)
4768    {
4769       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4770       return RFAILED;
4771    }
4772    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4773
4774    ulCfg->pusch_ServingCellConfig = NULLP;
4775    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4776          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4777    if(!ulCfg->pusch_ServingCellConfig)
4778    {
4779       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4780       return RFAILED;
4781    }
4782
4783    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4784    {
4785       return RFAILED;
4786    }
4787
4788    ulCfg->carrierSwitching = NULLP;
4789    ulCfg->ext1 = NULLP;
4790    return ROK;
4791 }
4792
4793 /*******************************************************************
4794  *
4795  * @brief Builds PDSCH serving cell config
4796  * @details
4797  *
4798  *    Function : BuildPdschSrvCellCfg
4799  *
4800  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4801  *
4802  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4803  *
4804  * @return ROK     - success
4805  *         RFAILED - failure
4806  *
4807  * ****************************************************************/
4808 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4809 {
4810    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4811    pdschCfg->choice.setup = NULLP;
4812    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4813    if(!pdschCfg->choice.setup)
4814    {
4815       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4816       return RFAILED;
4817    }
4818
4819    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4820    pdschCfg->choice.setup->xOverhead = NULLP;
4821    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4822    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4823    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4824    {
4825       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4826       return RFAILED;
4827    }
4828    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4829    pdschCfg->choice.setup->pucch_Cell = NULLP;
4830    pdschCfg->choice.setup->ext1 = NULLP;
4831
4832    return ROK;
4833 }
4834
4835 /*******************************************************************
4836  *
4837  * @brief Builds CSI Meas config
4838  * @details
4839  *
4840  *    Function : BuildCsiMeasCfg
4841  *
4842  *    Functionality: Builds CSI Meas config in spCellCfgDed
4843  *
4844  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4845  *
4846  * @return ROK     - success
4847  *         RFAILED - failure
4848  *
4849  * ****************************************************************/
4850 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4851 {
4852
4853    return ROK;
4854 }
4855
4856 /*******************************************************************
4857  *
4858  * @brief Builds Spcell config dedicated
4859  * @details
4860  *
4861  *    Function : BuildSpCellCfgDed
4862  *
4863  *    Functionality: Builds sp cell config dedicated in spCellCfg
4864  *
4865  * @params[in] ServingCellConfig_t srvCellCfg
4866  *
4867  * @return ROK     - success
4868  *         RFAILED - failure
4869  *
4870  * ****************************************************************/
4871 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4872 {
4873    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4874
4875    srvCellCfg->initialDownlinkBWP = NULLP;
4876    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4877    if(!srvCellCfg->initialDownlinkBWP)
4878    {
4879       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4880       return RFAILED;
4881    }
4882
4883    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4884    {
4885       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4886       return RFAILED;
4887    }
4888    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4889    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4890
4891    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4892    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4893    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4894    {
4895       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4896       return RFAILED;
4897    }
4898    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4899
4900    srvCellCfg->bwp_InactivityTimer = NULLP;
4901
4902    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4903    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4904    if(!srvCellCfg->defaultDownlinkBWP_Id)
4905    {
4906       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4907       return RFAILED;
4908    }
4909    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4910
4911    srvCellCfg->uplinkConfig = NULLP;
4912    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4913    if(!srvCellCfg->uplinkConfig)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4916       return RFAILED;
4917    }
4918
4919    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4920    {
4921       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4922       return RFAILED;
4923    }
4924    srvCellCfg->supplementaryUplink = NULLP;
4925    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4926
4927    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4928    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4929    if(!srvCellCfg->pdsch_ServingCellConfig)
4930    {
4931       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4932       return RFAILED;
4933    }
4934
4935    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4936    {
4937       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4938       return RFAILED;
4939    }
4940
4941    srvCellCfg->csi_MeasConfig = NULLP;
4942 #if 0
4943    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4944       if(!srvCellCfg->csi_MeasConfig)
4945       {
4946          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4947          return RFAILED;
4948       }
4949
4950    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4951    {
4952       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4953       return RFAILED;
4954    }
4955 #endif
4956    srvCellCfg->sCellDeactivationTimer = NULLP;
4957    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4958    srvCellCfg->tag_Id = TAG_ID;
4959    srvCellCfg->dummy = NULLP;
4960    srvCellCfg->pathlossReferenceLinking = NULLP;
4961    srvCellCfg->servingCellMO = NULLP;
4962    srvCellCfg->ext1 = NULLP;
4963
4964    return ROK;
4965 }
4966 /*******************************************************************
4967  *
4968  * @brief Builds Spcell config
4969  *
4970  * @details
4971  *
4972  *    Function : BuildSpCellCfg
4973  *
4974  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4975  *
4976  * @params[in] SpCellConfig_t spCellCfg
4977  *
4978  * @return ROK     - success
4979  *         RFAILED - failure
4980  *
4981  * ****************************************************************/
4982 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4983 {
4984
4985    spCellCfg->servCellIndex = NULLP;
4986    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4987    if(!spCellCfg->servCellIndex)
4988    {
4989       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4990       return RFAILED;
4991    }
4992    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4993
4994    spCellCfg->reconfigurationWithSync = NULLP;
4995    spCellCfg->rlf_TimersAndConstants = NULLP;
4996    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4997    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4998    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4999    {
5000       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5001       return RFAILED;
5002    }
5003    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5004
5005    spCellCfg->spCellConfigDedicated = NULLP;
5006    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5007    if(!spCellCfg->spCellConfigDedicated)
5008    {
5009       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5010       return RFAILED;
5011    }
5012    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5013    {
5014       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5015       return RFAILED;
5016    }
5017    return ROK;
5018 }
5019 /*******************************************************************
5020  *
5021  * @brief Builds Phy cell group config
5022  *
5023  * @details
5024  *
5025  *    Function : BuildPhyCellGrpCfg
5026  *
5027  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5028  *
5029  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5030  *
5031  * @return ROK     - success
5032  *         RFAILED - failure
5033  *
5034  * ****************************************************************/
5035 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5036 {
5037    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5038    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5039
5040    phyCellGrpCfg->p_NR_FR1 = NULLP;
5041    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5042    if(!phyCellGrpCfg->p_NR_FR1)
5043    {
5044       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5045       return RFAILED;
5046    }
5047    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5048    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5049    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5050    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5051    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5052    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5053    phyCellGrpCfg->cs_RNTI = NULLP;
5054    phyCellGrpCfg->ext1 = NULLP;
5055    phyCellGrpCfg->ext2 = NULLP;
5056
5057    return ROK;
5058 }
5059
5060 /*******************************************************************
5061  *
5062  * @brief Builds tag config
5063  *
5064  * @details
5065  *
5066  *    Function : BuildTagConfig
5067  *
5068  *    Functionality: Builds tag config in MacCellGroupConfig
5069  *
5070  * @params[in] TAG_Config *tag_Config
5071  *
5072  * @return ROK     - success
5073  *         RFAILED - failure
5074  *
5075  * ****************************************************************/
5076 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5077 {
5078    struct TAG_Config__tag_ToAddModList *tagList;
5079    uint8_t                     idx, elementCnt;
5080
5081    tagConfig->tag_ToReleaseList = NULLP;
5082    tagConfig->tag_ToAddModList = NULLP;
5083    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5084    if(!tagConfig->tag_ToAddModList)
5085    {
5086       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5087       return RFAILED;
5088    }
5089
5090    elementCnt = 1; //ODU_VALUE_ONE;
5091    tagList = tagConfig->tag_ToAddModList;
5092    tagList->list.count = elementCnt;
5093    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5094
5095    tagList->list.array = NULLP;
5096    CU_ALLOC(tagList->list.array, tagList->list.size);
5097    if(!tagList->list.array)
5098    {
5099       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5100       return RFAILED;
5101    }
5102
5103    for(idx=0; idx<tagList->list.count; idx++)
5104    {
5105       tagList->list.array[idx] = NULLP;
5106       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5107       if(!tagList->list.array[idx])
5108       {
5109          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5110          return RFAILED;
5111       }
5112    }
5113
5114    idx = 0;
5115    tagList->list.array[idx]->tag_Id = TAG_ID;
5116    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5117
5118    return ROK;
5119 }
5120
5121 /*******************************************************************
5122  *
5123  * @brief Builds PHR Config
5124  *
5125  * @details
5126  *
5127  *    Function : BuildPhrConfig
5128  *
5129  *    Functionality: Builds phrConfig in MacCellGroupConfig
5130  *
5131  * @params[in] PHR Config *
5132  *
5133  * @return ROK     - success
5134  *         RFAILED - failure
5135  *
5136  * ****************************************************************/
5137 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5138 {
5139
5140    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5141    phrConfig->choice.setup = NULLP;
5142    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5143    if(!phrConfig->choice.setup)
5144    {
5145       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5146       return RFAILED;
5147    }
5148
5149    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5150    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5151    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5152    phrConfig->choice.setup->multiplePHR              = false;
5153    phrConfig->choice.setup->dummy                    = false;
5154    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5155    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5156
5157    return ROK;
5158 }
5159
5160 /*******************************************************************
5161  *
5162  * @brief Builds BSR Config
5163  *
5164  * @details
5165  *
5166  *    Function : BuildBsrConfig
5167  *
5168  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5169  *
5170  * @params[in] BSR_Config *bsrConfig
5171  *
5172  * @return ROK     - success
5173  *         RFAILED - failure
5174  *
5175  * ****************************************************************/
5176 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5177 {
5178    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5179    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5180    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5181
5182    return ROK;
5183 }
5184
5185 /*******************************************************************
5186  *
5187  * @brief Builds scheduling request config
5188  *
5189  * @details
5190  *
5191  *    Function : BuildSchedulingReqConfig
5192  *
5193  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5194  *
5195  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5196  *
5197  * @return ROK     - success
5198  *         RFAILED - failure
5199  *
5200  * ****************************************************************/
5201 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5202 {
5203    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5204    uint8_t                     idx, elementCnt;
5205
5206    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5207    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5208          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5209    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5210    {
5211       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5212       return RFAILED;
5213    }
5214
5215    elementCnt = 1; //ODU_VALUE_ONE;
5216    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5217    schReqList->list.count = elementCnt;
5218    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5219
5220    schReqList->list.array = NULLP;
5221    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5222    if(!schReqList->list.array)
5223    {
5224       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5225       return RFAILED;
5226    }
5227
5228    for(idx=0;idx<schReqList->list.count; idx++)
5229    {
5230       schReqList->list.array[idx] = NULLP;
5231       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5232       if(!schReqList->list.array[idx])
5233       {
5234          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5235          return RFAILED;
5236       }
5237    }
5238
5239    idx = 0;
5240    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5241
5242    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5243    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5244    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5245    {
5246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5247       return RFAILED;
5248    }
5249    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5250    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5251    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5252
5253    return ROK;
5254 }
5255 /*******************************************************************
5256  *
5257  * @brief Builds Mac cell group config
5258  *
5259  * @details
5260  *
5261  *    Function : BuildMacCellGrpCfg
5262  *
5263  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5264  *
5265  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5266  *
5267  * @return ROK     - success
5268  *         RFAILED - failure
5269  *
5270  * ****************************************************************/
5271 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5272 {
5273    macCellGrpCfg->drx_Config = NULLP;
5274    macCellGrpCfg->schedulingRequestConfig = NULLP;
5275    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5276    if(!macCellGrpCfg->schedulingRequestConfig)
5277    {
5278       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5279       return RFAILED;
5280    }
5281
5282    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5283    {
5284       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5285       return RFAILED;
5286    }
5287
5288    macCellGrpCfg->bsr_Config = NULLP;
5289    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5290    if(!macCellGrpCfg->bsr_Config)
5291    {
5292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5293       return RFAILED;
5294    }
5295
5296    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5297    {
5298       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5299       return RFAILED;
5300    }
5301
5302    macCellGrpCfg->tag_Config = NULLP;
5303    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5304    if(!macCellGrpCfg->tag_Config)
5305    {
5306       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5307       return RFAILED;
5308    }
5309
5310    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5311    {
5312       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5313       return RFAILED;
5314    }
5315
5316    macCellGrpCfg->phr_Config = NULLP;
5317    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5318    if(!macCellGrpCfg->phr_Config)
5319    {
5320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5321       return RFAILED;
5322    }
5323
5324    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5325    {
5326       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5327       return RFAILED;
5328    }
5329
5330    macCellGrpCfg->skipUplinkTxDynamic = false;
5331    macCellGrpCfg->ext1 = NULLP;
5332
5333    return ROK;
5334 }
5335 /*******************************************************************
5336  *
5337  * @brief Frees memeory allocated for SearchSpcToAddModList
5338  *
5339  * @details
5340  *
5341  *    Function : FreeSearchSpcToAddModList
5342  *
5343  *    Functionality: Deallocating memory of SearchSpcToAddModList
5344  *
5345  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5346  *
5347  * @return void
5348  *
5349  4221 * ****************************************************************/
5350 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5351 {
5352    uint8_t idx1=0;
5353    uint8_t idx2=0;
5354    struct  SearchSpace *searchSpc=NULLP;
5355
5356    if(searchSpcList->list.array)
5357    {
5358       if(searchSpcList->list.array[idx2])
5359       {
5360          searchSpc = searchSpcList->list.array[idx2];
5361          if(searchSpc->controlResourceSetId)
5362          {
5363             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5364             {
5365                if(searchSpc->monitoringSymbolsWithinSlot)
5366                {
5367                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5368                   {
5369                      if(searchSpc->nrofCandidates)
5370                      {
5371                         if(searchSpc->searchSpaceType)
5372                         {
5373                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5374                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5375                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5376                                     SearchSpace__searchSpaceType));
5377                         }
5378                         CU_FREE(searchSpc->nrofCandidates,
5379                               sizeof(struct SearchSpace__nrofCandidates));
5380                      }
5381                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5382                            searchSpc->monitoringSymbolsWithinSlot->size);
5383                   }
5384                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5385                         sizeof(BIT_STRING_t));
5386                }
5387                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5388                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5389             }
5390             CU_FREE(searchSpc->controlResourceSetId,
5391                   sizeof(ControlResourceSetId_t));
5392          }
5393       }
5394       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5395       {
5396          CU_FREE(searchSpcList->list.array[idx1],
5397                sizeof(struct SearchSpace));
5398       }
5399       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5400    }
5401 }
5402 /*******************************************************************
5403  *
5404  * @brief Frees memory allocated for PdschTimeDomAllocList
5405  *
5406  * @details
5407  *
5408  *    Function : FreePdschTimeDomAllocList
5409  *
5410  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5411  *
5412  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5413  *
5414  * @return void
5415  *
5416  4221 * ****************************************************************/
5417 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5418 {
5419    uint8_t idx1=0;
5420
5421    if(timeDomAllocList->choice.setup)
5422    {
5423       if(timeDomAllocList->choice.setup->list.array)
5424       {
5425          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5426          {
5427             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5428                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5429          }
5430          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5431                timeDomAllocList->choice.setup->list.size);
5432       }
5433       CU_FREE(timeDomAllocList->choice.setup,\
5434             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5435    }
5436 }
5437 /*******************************************************************
5438  *
5439  * @brief Frees memory allocated for PuschTimeDomAllocList
5440  *
5441  *@details
5442  *
5443  *    Function : FreePuschTimeDomAllocList
5444  *
5445  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5446  *
5447  * @params[in] PUSCH_Config_t *puschCfg
5448  *
5449  * @return void
5450  *
5451  ***********************************************************************/
5452 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5453 {
5454    uint8_t idx1=0;
5455    uint8_t idx2=0;
5456    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5457
5458    if(puschCfg->pusch_TimeDomainAllocationList)
5459    {
5460       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5461       if(timeDomAllocList_t->choice.setup)
5462       {
5463          if(timeDomAllocList_t->choice.setup->list.array)
5464          {
5465             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5466             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5467             {
5468                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5469                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5470             }
5471             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5472                   timeDomAllocList_t->choice.setup->list.size);
5473          }
5474          CU_FREE(timeDomAllocList_t->choice.setup, \
5475                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5476       }
5477       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5478       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5479             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5480    }
5481
5482 }
5483
5484 /*******************************************************************
5485  *
5486  * @brief Frees memory allocated for Dedicated PUCCH config
5487  *
5488  * @details
5489  *
5490  *    Function : FreeBWPUlDedPucchCfg
5491  *
5492  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5493  *
5494  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5495  *
5496  * @return void
5497  *
5498  * ****************************************************************/
5499 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5500 {
5501    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5502    PUCCH_Config_t *pucchCfg = NULLP;
5503    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5504    PUCCH_Resource_t *rsrc = NULLP;
5505
5506    if(ulBwpPucchCfg)
5507    {
5508       if(ulBwpPucchCfg->choice.setup)
5509       {
5510          pucchCfg = ulBwpPucchCfg->choice.setup;
5511
5512          //Free resource set list
5513          if(pucchCfg->resourceSetToAddModList)
5514          {
5515             if(pucchCfg->resourceSetToAddModList->list.array)
5516             {
5517                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5518                {
5519                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5520                   if(rsrcSet->resourceList.list.array)
5521                   {
5522                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5523                      {
5524                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5525                      }
5526                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5527                   }
5528                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5529                }
5530                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5531             }
5532             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5533          }
5534
5535          //Free resource list
5536          if(pucchCfg->resourceToAddModList)
5537          {
5538             if(pucchCfg->resourceToAddModList->list.array)
5539             {
5540                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5541                {
5542                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5543                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5544                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5545                }
5546                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5547             }
5548             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5549          }
5550
5551          //PUCCH Format 1
5552          if(pucchCfg->format1)
5553          {
5554             if(pucchCfg->format1->choice.setup)
5555             {
5556                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5557                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5558             }
5559             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5560          }
5561
5562          //DL DATA TO UL ACK
5563          if(pucchCfg->dl_DataToUL_ACK)
5564          {
5565             if(pucchCfg->dl_DataToUL_ACK->list.array)
5566             {
5567                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5568                {
5569                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5570                }
5571                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5572             }
5573             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5574          }
5575
5576          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5577       }
5578       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5579    }
5580 }
5581
5582 /*******************************************************************
5583  *
5584  * @brief Frees memory allocated for InitialUlBWP
5585  *
5586  * @details
5587  *
5588  *    Function : FreeInitialUlBWP
5589  *
5590  *    Functionality: Deallocating memory of InitialUlBWP
5591  *
5592  * @params[in] BWP_UplinkDedicated_t *ulBwp
5593  *
5594  * @return void
5595  *
5596  * ****************************************************************/
5597 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5598 {
5599    uint8_t  rSetIdx, rsrcIdx;
5600    SRS_Config_t   *srsCfg = NULLP;
5601    PUSCH_Config_t *puschCfg = NULLP;
5602    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5603    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5604    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5605    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5606
5607    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5608
5609    if(ulBwp->pusch_Config)
5610    {
5611       if(ulBwp->pusch_Config->choice.setup)
5612       {
5613          puschCfg=ulBwp->pusch_Config->choice.setup;
5614          if(puschCfg->dataScramblingIdentityPUSCH)
5615          {
5616             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5617             {
5618                FreePuschTimeDomAllocList(puschCfg);
5619                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5620                if(dmrsUlCfg->choice.setup)
5621                {
5622                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5623                   {
5624                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5625                      {
5626                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5627                               sizeof(long));
5628                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5629                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5630                      }
5631                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5632                            sizeof(long));
5633                   }
5634                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5635                }
5636                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5637                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5638             }
5639             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5640          }
5641          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5642       }
5643       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5644
5645       /* Free SRS-Config */
5646       if(ulBwp->srs_Config)
5647       {
5648          if(ulBwp->srs_Config->choice.setup)
5649          {
5650             srsCfg = ulBwp->srs_Config->choice.setup;
5651
5652             /* Free Resource Set to add/mod list */
5653             if(srsCfg->srs_ResourceSetToAddModList)
5654             {
5655                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5656                if(rsrcSetList->list.array)
5657                {
5658                   rSetIdx = 0;
5659
5660                   /* Free SRS resource Id list in this SRS resource set */
5661                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5662                   {
5663                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5664
5665                      if(rsrcIdList->list.array)
5666                      {
5667                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5668                         {
5669                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5670                         }
5671                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5672                      }
5673                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5674                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5675                   }
5676
5677                   /* Free resource type info for this SRS resource set */
5678                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5679                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5680
5681                   /* Free memory for each resource set */
5682                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5683                   {
5684                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5685                   }
5686                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5687                }
5688                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5689                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5690             }
5691
5692             /* Free resource to add/modd list */
5693             if(srsCfg->srs_ResourceToAddModList)
5694             {
5695                resourceList = srsCfg->srs_ResourceToAddModList;
5696                if(resourceList->list.array)
5697                {
5698                   rsrcIdx = 0;
5699                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5700                         sizeof(struct SRS_Resource__transmissionComb__n2));
5701                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5702                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5703
5704                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5705                   {
5706                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5707                   }
5708                   CU_FREE(resourceList->list.array, resourceList->list.size);
5709                }
5710                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5711                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5712             }
5713
5714             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5715          }
5716          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5717       }
5718    }
5719 }
5720 /*******************************************************************
5721  *
5722  * @brief Frees memory allocated for initialUplinkBWP
5723  *
5724  * @details
5725  *
5726  *    Function : FreeinitialUplinkBWP
5727  *
5728  *    Functionality: Deallocating memory of initialUplinkBWP
5729  *
5730  * @params[in] UplinkConfig_t *ulCfg
5731  *
5732  * @return void
5733  *
5734  *
5735  * ****************************************************************/
5736 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5737 {
5738    BWP_UplinkDedicated_t *ulBwp=NULLP;
5739    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5740
5741    if(ulCfg->initialUplinkBWP)
5742    {
5743       ulBwp=ulCfg->initialUplinkBWP;
5744       if(ulCfg->firstActiveUplinkBWP_Id)
5745       {
5746          if(ulCfg->pusch_ServingCellConfig)
5747          {
5748             puschCfg=ulCfg->pusch_ServingCellConfig;
5749             if(puschCfg->choice.setup)
5750             {
5751                if(puschCfg->choice.setup->ext1)
5752                {
5753                   CU_FREE(puschCfg->choice.setup->ext1->\
5754                         processingType2Enabled,sizeof(BOOLEAN_t));
5755                   CU_FREE(puschCfg->choice.setup->ext1->\
5756                         maxMIMO_Layers,sizeof(long));
5757                   CU_FREE(puschCfg->choice.setup->ext1, \
5758                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5759                }
5760                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5761             }
5762             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5763          }
5764          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5765       }
5766       FreeInitialUlBWP(ulBwp);
5767       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5768    }
5769 }
5770 /*******************************************************************
5771  *
5772  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5773  *
5774  * @details
5775  *
5776  *    Function : FreeBWPDlDedPdschCfg
5777  *
5778  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5779  *
5780  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5781  *
5782  * @return void
5783  *
5784  *
5785  * ****************************************************************/
5786 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5787 {
5788    struct PDSCH_Config *pdschCfg=NULLP;
5789    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5790    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5791    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5792
5793    if(dlBwp->pdsch_Config->choice.setup)
5794    {
5795       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5796       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5797       {
5798          if(pdschCfg->pdsch_TimeDomainAllocationList)
5799          {
5800             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5801             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5802             {
5803                prbBndlType=&pdschCfg->prb_BundlingType;
5804                CU_FREE(prbBndlType->choice.staticBundling,\
5805                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5806                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5807             }
5808             FreePdschTimeDomAllocList(timeDomAllocList);
5809             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5810                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5811          }
5812          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5813          if(dmrsDlCfg->choice.setup)
5814          {
5815             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5816                   sizeof(long));
5817             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5818          }
5819          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5820                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5821       }
5822       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5823    }
5824 }
5825 /*******************************************************************
5826  *
5827  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5828  *
5829  * @details
5830  *
5831  *    Function : FreeBWPDlDedPdcchCfg
5832  *
5833  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5834  *
5835  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5836  *
5837  * @return void
5838  *
5839  *
5840  * ****************************************************************/
5841 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5842 {
5843    uint8_t idx1=0;
5844    uint8_t idx2=0;
5845    struct PDCCH_Config *pdcchCfg=NULLP;
5846    struct ControlResourceSet *controlRSet=NULLP;
5847    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5848
5849    if(dlBwp->pdcch_Config->choice.setup)
5850    {
5851       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5852       if(pdcchCfg->controlResourceSetToAddModList)
5853       {
5854          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5855          if(controlRSetList->list.array)
5856          {
5857             controlRSet = controlRSetList->list.array[idx2];
5858             if(controlRSet)
5859             {
5860                if(controlRSet->frequencyDomainResources.buf)
5861                {
5862                   if(controlRSet->pdcch_DMRS_ScramblingID)
5863                   {
5864                      if(pdcchCfg->searchSpacesToAddModList)
5865                      {
5866                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5867                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5868                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5869                      }
5870                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5871                   }
5872                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5873                         controlRSet->frequencyDomainResources.size);
5874                }
5875             }
5876             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5877             {
5878                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5879             }
5880             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5881          }
5882          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5883                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5884       }
5885       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5886    }
5887 }
5888 /*******************************************************************
5889  *
5890  * @brief Builds RLC Config
5891  *
5892  * @details
5893  *
5894  *    Function : BuildRlcConfig
5895  *
5896  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5897  *
5898  * @params[in] RLC_Config *rlcConfig
5899  *
5900  * @return ROK     - success
5901  *         RFAILED - failure
5902  *
5903  * ****************************************************************/
5904 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
5905 {
5906    rlcConfig->present = rlcLcCfgDb.rlcMode;
5907
5908    switch(rlcConfig->present)
5909    {
5910       case RLC_Config_PR_am:
5911          {
5912             rlcConfig->choice.am = NULLP;
5913             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5914             if(!rlcConfig->choice.am)
5915             {
5916                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5917                return RFAILED;
5918             }
5919
5920             /* UL */
5921             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5922             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5923             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5924             {
5925                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5926                return RFAILED;
5927             }
5928             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
5929             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
5930             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
5931             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
5932             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
5933
5934             /* DL */
5935             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5936             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5937             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5938             {
5939                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5940                return RFAILED;
5941             }
5942             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
5943             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
5944             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
5945
5946             break;
5947          }
5948
5949       case RLC_Config_PR_um_Bi_Directional:
5950          {
5951             rlcConfig->choice.um_Bi_Directional = NULLP;
5952             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
5953             if(!rlcConfig->choice.um_Bi_Directional)
5954             {
5955                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5956                return RFAILED;
5957             }
5958
5959             /* UL */
5960             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
5961             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5962             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
5963             {
5964                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5965                return RFAILED;
5966             }
5967             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
5968
5969             /* DL */
5970             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
5971             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5972             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
5973             {
5974                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5975                return RFAILED;
5976             }
5977             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
5978             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
5979             break;
5980          }
5981    }
5982    return ROK;
5983 }
5984
5985 /*******************************************************************
5986  *
5987  * @brief Builds MAC LC Config
5988  *
5989  * @details
5990  *
5991  *    Function : BuildMacLCConfig
5992  *
5993  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5994  *
5995  * @params[in] struct LogicalChannelConfig macLcConfig
5996  *
5997  * @return ROK     - success
5998  *         RFAILED - failure
5999  *
6000  * ****************************************************************/
6001 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6002 {
6003
6004    macLcConfig->ul_SpecificParameters = NULLP;
6005    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6006    if(!macLcConfig->ul_SpecificParameters)
6007    {
6008       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6009       return RFAILED;
6010    }
6011
6012    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6013    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6014    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6015    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6016    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6017    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6018    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6019
6020    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6021    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6022    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6023    {
6024       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6025       return RFAILED;
6026    }
6027    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6028
6029    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6030    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6031    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6032    {
6033       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6034       return RFAILED;
6035    }
6036    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6037
6038    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6039    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6040    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6041
6042    return ROK;
6043 }
6044 /*******************************************************************
6045  *
6046  * @brief Builds RLC Bearer to Add/Mod list
6047  *
6048  * @details
6049  *
6050  *    Function :BuildRlcBearerToAddModList
6051  *
6052  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6053  *
6054  * @params[in] rlc_BearerToAddModList
6055  *
6056  * @return ROK     - success
6057  *         RFAILED - failure
6058  *
6059  * ****************************************************************/
6060 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6061 {
6062    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6063
6064    if(updateAllRbCfg)
6065       elementCnt = ueCb->numSrb + ueCb->numDrb;
6066    else
6067    {
6068       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6069       {
6070          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6071             elementCnt++;
6072       }
6073
6074       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6075       {
6076          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6077             elementCnt++;
6078       }
6079    }
6080
6081    if(!elementCnt)
6082    {
6083       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6084       return ROK;
6085    }
6086    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6087    if(!rlcBearerList)
6088    {
6089       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6090       return RFAILED;
6091    }
6092    rlcBearerList->list.count = elementCnt;
6093    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6094
6095    rlcBearerList->list.array = NULLP;
6096    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6097    if(!rlcBearerList->list.array)
6098    {
6099       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6100       return RFAILED;
6101    }
6102
6103    for(idx=0; idx<rlcBearerList->list.count; idx++)
6104    {
6105       rlcBearerList->list.array[idx] = NULLP;
6106       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6107       if(!rlcBearerList->list.array[idx])
6108       {
6109          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6110          return RFAILED;
6111       }
6112    }
6113
6114    idx = 0;
6115
6116    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6117    {
6118       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6119          continue;
6120
6121       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6122
6123       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6124       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6125       {
6126          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6127          return RFAILED;
6128       }
6129
6130       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6131       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6132
6133       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6134       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6135       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6136       if(!rlcBearerList->list.array[idx]->rlc_Config)
6137       {
6138          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6139          return RFAILED;
6140       }
6141
6142       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6143       {
6144          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6145          return RFAILED;
6146       }
6147
6148       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6149       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6150       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6151       {
6152          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6153          return RFAILED;
6154       }
6155
6156       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6157       {
6158          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6159          return RFAILED;
6160       }
6161       idx++;
6162    }
6163
6164    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6165    {
6166       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6167          continue;
6168
6169       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6170
6171       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6172       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6173       {
6174          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6175          return RFAILED;
6176       }
6177
6178       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6179       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6180
6181       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6182       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6183       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6184       if(!rlcBearerList->list.array[idx]->rlc_Config)
6185       {
6186          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6187          return RFAILED;
6188       }
6189
6190       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6191       {
6192          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6193          return RFAILED;
6194       }
6195
6196       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6197       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6198       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6199       {
6200          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6201          return RFAILED;
6202       }
6203
6204       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6205       {
6206          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6207          return RFAILED;
6208       }
6209       idx++;
6210    }
6211    return ROK;
6212 }
6213
6214 /*******************************************************************
6215  *
6216  * @brief Free memory allocated for CellGroupConfig
6217  *
6218  * @details
6219  *
6220  *    Function : FreeMemCellGrpCfg
6221  *
6222  *    Functionality: Deallocating memory of CellGroupConfig
6223  *
6224  * @params[in] pointer to CellGroupConfigRrc_t
6225  *
6226  * @return ROK     - success
6227  *         RFAILED - failure
6228  *
6229  ******************************************************************/
6230 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6231 {
6232    uint8_t idx=0;
6233    SpCellConfig_t *spCellCfg=NULLP;
6234    ServingCellConfig_t *srvCellCfg=NULLP;
6235    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6236    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6237    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6238    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6239    struct RLC_Config *rlcConfig=NULLP;
6240    struct LogicalChannelConfig *macLcConfig=NULLP;
6241    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6242    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6243    struct TAG_Config *tagConfig=NULLP;
6244    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6245    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6246    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6247
6248    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6249    if(rlcBearerList)
6250    {
6251       if(rlcBearerList->list.array)
6252       {
6253          for(idx=0; idx<rlcBearerList->list.count; idx++)
6254          {
6255             if(rlcBearerList->list.array[idx])
6256             {
6257                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6258                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6259                if(rlcConfig)
6260                {
6261                   if(rlcConfig->choice.am)
6262                   {
6263                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6264                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6265                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6266                   }
6267                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6268                }
6269                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6270                if(macLcConfig)
6271                {
6272                   if(macLcConfig->ul_SpecificParameters)
6273                   {
6274                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6275                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6276                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6277                   }
6278                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6279                }
6280                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6281             }
6282          }
6283          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6284       }
6285       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6286    }
6287
6288    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6289    if(macCellGrpCfg)
6290    {
6291       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6292       if(schedulingRequestConfig)
6293       {
6294          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6295          if(schReqList)
6296          {
6297             if(schReqList->list.array)
6298             {
6299                for(idx=0;idx<schReqList->list.count; idx++)
6300                {
6301                   if(schReqList->list.array[idx])
6302                   {
6303                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6304                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6305                   }
6306                }
6307                CU_FREE(schReqList->list.array, schReqList->list.size);
6308             }
6309             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6310                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6311             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6312       }
6313       if(macCellGrpCfg->bsr_Config)
6314       {
6315          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6316       }
6317       tagConfig = macCellGrpCfg->tag_Config;
6318       if(tagConfig)
6319       {
6320          tagList = tagConfig->tag_ToAddModList;
6321          if(tagList)
6322          {
6323             if(tagList->list.array)
6324             {
6325                for(idx=0; idx<tagList->list.count; idx++)
6326                {
6327                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6328                }
6329                CU_FREE(tagList->list.array, tagList->list.size);
6330             }
6331             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6332          }
6333          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6334       }
6335
6336       phrConfig = macCellGrpCfg->phr_Config;
6337       if(phrConfig)
6338       {
6339          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6340          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6341       }
6342
6343       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6344    }
6345
6346    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6347    if(phyCellGrpCfg)
6348    {
6349       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6350       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6351    }
6352
6353    spCellCfg = cellGrpCfg->spCellConfig;
6354    if(spCellCfg)
6355    {
6356       if(spCellCfg->servCellIndex)
6357       {
6358          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6359          {
6360             if(spCellCfg->spCellConfigDedicated)
6361             {
6362                srvCellCfg = spCellCfg->spCellConfigDedicated;
6363                if(srvCellCfg->initialDownlinkBWP)
6364                {
6365                   dlBwp = srvCellCfg->initialDownlinkBWP;
6366                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6367                   {
6368                      if(srvCellCfg->defaultDownlinkBWP_Id)
6369                      {
6370                         if(srvCellCfg->uplinkConfig)
6371                         {
6372                            if(srvCellCfg->pdsch_ServingCellConfig)
6373                            {
6374                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6375                               if(pdschCfg->choice.setup)
6376                               {
6377                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6378                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6379                               }
6380                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6381                                        ServingCellConfig__pdsch_ServingCellConfig));
6382                            }
6383                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6384                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6385                         }
6386                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6387                      }
6388                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6389                   }
6390                   if(dlBwp->pdcch_Config)
6391                   {
6392                      if(dlBwp->pdsch_Config)
6393                      {
6394                         FreeBWPDlDedPdschCfg(dlBwp);
6395                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6396                      }
6397                      FreeBWPDlDedPdcchCfg(dlBwp);
6398                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6399                   }
6400                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6401                }
6402                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6403             }
6404             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6405          }
6406          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6407       }
6408       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6409    }
6410    return ROK;
6411 }
6412
6413 /*******************************************************************
6414  *
6415  * @brief Fills CellGroupConfig
6416  *
6417  * @details
6418  *
6419  *    Function : fillCellGrpCfg
6420  *
6421  *    Functionality: Fills CellGroupConfig
6422  *
6423  * @params[in] pointer to CellGroupConfigRrc_t
6424  *
6425  * @return ROK     - success
6426  *         RFAILED - failure
6427  *
6428  ******************************************************************/
6429
6430 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6431 {
6432    uint8_t               ret = RFAILED;
6433    CellGroupConfigRrc_t  cellGrpCfg;
6434    asn_enc_rval_t        encRetVal;
6435
6436    while(true)
6437    {
6438       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6439
6440       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6441
6442       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6443       {
6444          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6445          break;
6446       }
6447
6448       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6449       cellGrpCfg.mac_CellGroupConfig = NULLP;
6450       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6451       if(!cellGrpCfg.mac_CellGroupConfig)
6452       {
6453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6454          break;
6455       }
6456       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6457       {
6458          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6459          break;
6460       }
6461
6462       cellGrpCfg.physicalCellGroupConfig = NULLP;
6463       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6464       if(!cellGrpCfg.physicalCellGroupConfig)
6465       {
6466          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6467          break;
6468       }
6469       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6470       {
6471          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6472          break;
6473       }
6474
6475       cellGrpCfg.spCellConfig = NULLP;
6476       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6477       if(!cellGrpCfg.spCellConfig)
6478       {
6479          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6480          break;
6481       }
6482       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6483       {
6484          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6485          break;
6486       }
6487
6488       cellGrpCfg.sCellToAddModList = NULLP;
6489       cellGrpCfg.sCellToReleaseList = NULLP;
6490       cellGrpCfg.ext1 = NULLP;
6491
6492       /* encode cellGrpCfg into duToCuRrcContainer */
6493       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6494       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6495       encBufSize = 0;
6496       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6497       /* Encode results */
6498       if(encRetVal.encoded == ENCODE_FAIL)
6499       {
6500          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6501                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6502          break;
6503       }
6504       else
6505       {
6506          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6507          for(int i=0; i< encBufSize; i++)
6508          {
6509             DU_LOG("%x",encBuf[i]);
6510          }
6511       }
6512
6513       cellGrp->size = encBufSize;
6514       CU_ALLOC(cellGrp->buf, cellGrp->size);
6515       if(!cellGrp->buf)
6516       {
6517          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6518          break;
6519       }
6520       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6521       ret = ROK;
6522       break;
6523    }
6524    FreeMemCellGrpCfg(&cellGrpCfg);
6525    return ret;
6526 }
6527
6528 /*******************************************************************
6529  *
6530  * @brief Free UE Capability RAT container
6531  *
6532  * @details
6533  *
6534  *    Function : freeUeCapRatCont
6535  *
6536  *    Functionality:
6537  *       Free UE Capability RAT conatiner
6538  *
6539  * @params[in]
6540  * @return ROK     - success
6541  *         RFAILED - failure
6542  *
6543  * ****************************************************************/
6544 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6545 {
6546    uint8_t idx;
6547    FeatureSets_t *featureSets;
6548
6549    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6550    {
6551       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6552       {
6553          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6554             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6555       }
6556       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6557    }
6558
6559    if(ueNrCap->featureSets)
6560    {
6561       featureSets = ueNrCap->featureSets;
6562       if(featureSets->featureSetsDownlinkPerCC)
6563       {
6564          if(featureSets->featureSetsDownlinkPerCC->list.array)
6565          {
6566             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6567             {
6568                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6569                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6570                         sizeof(ModulationOrder_t));
6571                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6572             }
6573             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6574          }
6575          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6576       }
6577
6578       if(featureSets->featureSetsUplinkPerCC)
6579       {
6580          if(featureSets->featureSetsUplinkPerCC->list.array)
6581          {
6582             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6583             {
6584                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6585                {
6586                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6587                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6588                          sizeof(ModulationOrder_t));
6589                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6590                }
6591             }
6592             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6593          }
6594          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6595       }
6596       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6597    }
6598 }
6599
6600 /*******************************************************************
6601  *
6602  * @brief Free UE capability RAT container list
6603  *
6604  * @details
6605  *
6606  *    Function : freeUeCapRatContList
6607  *
6608  *    Functionality: Free UE capability RAT container list
6609  *
6610  * @params[in]
6611  * @return ROK     - success
6612  *         RFAILED - failure
6613  *
6614  * ****************************************************************/
6615 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6616 {
6617    uint8_t idx;
6618    if(ueCapablityList->list.array)
6619    {
6620       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6621       {
6622          if(ueCapablityList->list.array[idx])
6623             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6624       }
6625       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6626    }
6627 }
6628
6629 /*******************************************************************
6630  *
6631  * @brief Free Handover preparation information
6632  *
6633  * @details
6634  *
6635  *    Function : freeHOPreparationInfo
6636  *
6637  *    Functionality: Free Handover preparation information
6638  *
6639  * @params[in]
6640  * @return ROK     - success
6641  *         RFAILED - failure
6642  *
6643  * ****************************************************************/
6644 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6645 {
6646    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6647
6648    if(hoPrep->criticalExtensions.choice.c1)
6649    {
6650       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6651       {
6652          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6653          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6654          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6655                sizeof(HandoverPreparationInformationRrc_IEs_t));
6656       }
6657       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6658    }
6659 }
6660
6661 /*******************************************************************
6662  *
6663  * @brief Fill feature sets
6664  *
6665  * @details
6666  *
6667  *    Function : fillFeatureSets
6668  *
6669  *    Functionality: Fill feature sets
6670  *
6671  * @params[in]
6672  * @return ROK     - success
6673  *         RFAILED - failure
6674  *
6675  * ****************************************************************/
6676 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6677 {
6678    uint8_t idx, elementCnt;
6679
6680    featureSets->featureSetsDownlink = NULLP;
6681    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6682    if(!featureSets->featureSetsDownlinkPerCC)
6683    {
6684       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6685       return RFAILED;
6686    }
6687
6688    elementCnt = 1;
6689    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6690    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6691    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6692    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6693    {
6694       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6695       return RFAILED;
6696    }
6697
6698    for(idx = 0; idx < elementCnt; idx++)
6699    {
6700       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6701       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6702       {
6703          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6704          return RFAILED;
6705       }
6706    }
6707
6708    idx = 0;
6709    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6710    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6711    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6712    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6713    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6714
6715    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6716    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6717    {
6718       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6719       return RFAILED;
6720    }
6721    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6722
6723    featureSets->featureSetsUplink = NULLP;
6724    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6725    if(!featureSets->featureSetsUplinkPerCC)
6726    {
6727       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6728       return RFAILED;
6729    }
6730
6731    elementCnt = 1;
6732    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6733    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6734    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6735    if(!featureSets->featureSetsUplinkPerCC->list.array)
6736    {
6737       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6738       return RFAILED;
6739    }
6740
6741    for(idx = 0; idx < elementCnt; idx++)
6742    {
6743       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6744       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6745       {
6746          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6747          return RFAILED;
6748       }
6749    }
6750
6751    idx = 0;
6752    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6753    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6754    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6755    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6756    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6757    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6758
6759    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6760    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6761    {
6762       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6763       return RFAILED;
6764    }
6765    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6766
6767    return ROK;
6768 }
6769
6770 /*******************************************************************
6771  *
6772  * @brief Fill UE capability RAT container
6773  *
6774  * @details
6775  *
6776  *    Function : fillUeCapRatCont
6777  *
6778  *    Functionality: Fill UE capability RAT container
6779  *
6780  * @params[in] UE Capability RAT container buffer
6781  * @return ROK     - success
6782  *         RFAILED - failure
6783  *
6784  * ****************************************************************/
6785 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6786 {
6787    uint8_t             ret = ROK;
6788    uint8_t             idx, elementCnt;
6789    asn_enc_rval_t      encRetVal;
6790    UE_NR_Capability_t  ueNrCap;
6791
6792    while(true)
6793    {
6794       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6795
6796       /* Filling PDCP parameters */
6797       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6798       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6799       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6800       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6801       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6802       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6803       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6804       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6805       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6806       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6807       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6808       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6809       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6810       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6811       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6812       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6813       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6814
6815       ueNrCap.rlc_Parameters = NULLP;
6816       ueNrCap.mac_Parameters = NULLP;
6817
6818       /* Filling PHY parameters */
6819       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6820       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6821       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6822       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6823       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6824
6825       /* Filling RF parameters */
6826       elementCnt = 1;
6827       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6828       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6829       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6830       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6831       {
6832          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6833          ret = RFAILED;
6834          break;
6835       }
6836
6837       for(idx = 0; idx < elementCnt; idx++)
6838       {
6839          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6840          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6841          {
6842             ret = RFAILED;
6843             break;
6844          }
6845       }
6846       if(ret == RFAILED)
6847          break;
6848
6849       idx = 0;
6850       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6851       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6852       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6853
6854       ueNrCap.measAndMobParameters = NULLP;
6855       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6856       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6857       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6858       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6859       ueNrCap.featureSets = NULLP;
6860
6861       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6862       if(!ueNrCap.featureSets)
6863       {
6864          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6865          ret = RFAILED;
6866          break;
6867       }
6868
6869       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6870       {
6871          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6872          ret = RFAILED;
6873          break;
6874       }
6875
6876       ueNrCap.featureSetCombinations = NULLP;
6877       ueNrCap.lateNonCriticalExtension = NULLP;
6878       ueNrCap.nonCriticalExtension = NULLP;
6879
6880       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6881       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6882       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6883       encBufSize = 0;
6884       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6885
6886       /* Encode results */
6887       if(encRetVal.encoded == ENCODE_FAIL)
6888       {
6889          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6890             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6891          break;
6892       }
6893       else
6894       {
6895          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6896          for(int i=0; i< encBufSize; i++)
6897          {
6898             DU_LOG("%x",encBuf[i]);
6899          }
6900       }
6901
6902       ueCapRatContBuf->size = encBufSize;
6903       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6904       if(!ueCapRatContBuf->buf)
6905       {
6906          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6907          break;
6908       }
6909       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6910       ret = ROK;
6911       break;
6912    }
6913    freeUeCapRatCont(&ueNrCap);
6914    return ROK;
6915 }
6916
6917 /*******************************************************************
6918  *
6919  * @brief Fill UE Capability RAT container list
6920  *
6921  * @details
6922  *
6923  *    Function : fillUeCapRatContList
6924  *
6925  *    Functionality: Fill UE Capability RAT container list
6926
6927  *
6928  * @params[in] UE capability RAT container list
6929  * @return ROK     - success
6930  *         RFAILED - failure
6931  *
6932  * ****************************************************************/
6933 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
6934 {
6935     uint8_t          ret = RFAILED;
6936     uint8_t          idx, elementCnt;
6937
6938     while(true)
6939     {
6940        elementCnt = 1;
6941        ueCapablityList->list.count = elementCnt;
6942        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6943
6944        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
6945        if(!ueCapablityList->list.array)
6946        {
6947           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6948           ret = RFAILED;
6949           break;
6950        }
6951
6952        for(idx=0; idx<elementCnt; idx++)
6953        {
6954           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6955           if(ueCapablityList->list.array[idx] == NULLP)
6956           {
6957              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6958              ret = RFAILED;
6959              break;
6960           }
6961        }
6962        idx = 0;
6963        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
6964        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
6965        {
6966           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
6967           ret = RFAILED;
6968           break;
6969        }
6970
6971        ret = ROK;
6972        break;
6973     }
6974     return ret;
6975 }
6976
6977 /*******************************************************************
6978  *
6979  * @brief Fill UE Capability RAT container list octet string
6980  *
6981  * @details
6982  *
6983  *    Function : fillUeCapRatContListBuf
6984  *
6985  *    Functionality: Fill UE Capability RAT container list octet string
6986
6987  *
6988  * @params[in] UE capability RAT container list buffer
6989  * @return ROK     - success
6990  *         RFAILED - failure
6991  *
6992  * ****************************************************************/
6993 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6994 {
6995    uint8_t          ret = RFAILED;
6996    asn_enc_rval_t   encRetVal;
6997    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
6998
6999    while(true)
7000    {
7001       ret = fillUeCapRatContList(&ueCapablityList);
7002       if(ret != ROK)
7003       {
7004          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7005          break;
7006       }
7007
7008       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7009       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7010       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7011       encBufSize = 0;
7012       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7013             &ueCapablityList, PrepFinalEncBuf, encBuf);
7014
7015       /* Encode results */
7016       if(encRetVal.encoded == ENCODE_FAIL)
7017       {
7018          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7019                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7020          break;
7021       }
7022       else
7023       {
7024          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7025          for(int i=0; i< encBufSize; i++)
7026          {
7027             DU_LOG("%x",encBuf[i]);
7028          }
7029       }
7030
7031       ueCapablityListBuf->size = encBufSize;
7032       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7033       if(!ueCapablityListBuf->buf)
7034       {
7035          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7036          break;
7037       }
7038       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7039       ret = ROK;
7040       break;
7041    }
7042    freeUeCapRatContList(&ueCapablityList);
7043    return ret;
7044 }
7045
7046 /*******************************************************************
7047  *
7048  * @brief Free Measurement Timing Configuration
7049  *
7050  * @details
7051  *
7052  *    Function : freeMeasuementTimingConfig
7053  *
7054  *    Functionality: Free Measurement Timing Configuration
7055  *
7056  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7057  * @return void
7058  *
7059  * ****************************************************************/
7060 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7061 {
7062    uint8_t measCfgIdx;
7063    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7064    MeasTiming_t *measTiming = NULLP;
7065
7066    if(measTimingConfig.criticalExtensions.choice.c1)
7067    {
7068       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7069       {
7070          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7071          if(measTimingCfg->measTiming)
7072          {
7073             if(measTimingCfg->measTiming->list.array)
7074             {
7075                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7076                {
7077                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7078                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7079                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7080                }
7081                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7082             }
7083             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7084          }
7085          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7086       }
7087       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7088    }
7089 }
7090
7091 /*******************************************************************
7092  *
7093  * @brief Fill Measurement Timing Configuration
7094  *
7095  * @details
7096  *
7097  *    Function : fillMeasTimingCfg
7098  *
7099  *    Functionality: Fill Measurement Timing Configuration
7100  *
7101  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7102  * @return ROK     - success
7103  *         RFAILED - failure
7104  *
7105  * ****************************************************************/
7106 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7107 {
7108    uint8_t elementCnt = 0;
7109    uint8_t measCfgIdx = 0;
7110    MeasTiming_t *measTiming;
7111    SSB_MTC_t *smtc;
7112
7113    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7114    if(!measTimingCfg->measTiming)
7115    {
7116       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7117       return RFAILED;
7118    }
7119
7120    elementCnt = 1;
7121    measTimingCfg->measTiming->list.count = elementCnt;
7122    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7123    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7124    if(!measTimingCfg->measTiming->list.array)
7125    {
7126       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7127       return RFAILED;
7128    }
7129
7130    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7131    {
7132       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7133       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7134       {
7135          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7136          return RFAILED;
7137       }
7138    }
7139
7140    measCfgIdx = 0;
7141    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7142    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7143    if(!measTiming->frequencyAndTiming)
7144    {
7145       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7146       return RFAILED;
7147    }
7148
7149    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7150    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7151
7152    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7153    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7154    smtc->periodicityAndOffset.choice.sf20 = 0;
7155    smtc->duration = SSB_MTC__duration_sf1;
7156    return ROK;
7157 }
7158
7159 /*******************************************************************
7160  *
7161  * @brief Fill Measurement Timing Configuration Octet string
7162  *
7163  * @details
7164  *
7165  *    Function : fillMeasConfigBuf
7166  *
7167  *    Functionality: Fill Measurement Timing Configuration Octet string
7168
7169  *
7170  * @params[in] MeasConfig_t *measConfgBuf
7171  * @return ROK     - success
7172  *         RFAILED - failure
7173  *
7174  * ****************************************************************/
7175 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7176 {
7177    uint8_t          ret = RFAILED;
7178    asn_enc_rval_t   encRetVal;
7179    MeasurementTimingConfigurationRrc_t measTimingConfig;
7180
7181    while(true)
7182    {
7183       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7184       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7185       if(!measTimingConfig.criticalExtensions.choice.c1)
7186       {
7187          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7188          return RFAILED;
7189       }
7190       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7191
7192       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7193       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7194       {
7195          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7196          return RFAILED;
7197       }
7198
7199       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7200       if(ret != ROK)
7201       {
7202          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7203          break;
7204       }
7205
7206       /* Encode measurement timing configuration into octet string */
7207       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7208       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7209       encBufSize = 0;
7210       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7211
7212       /* Encode results */
7213       if(encRetVal.encoded == ENCODE_FAIL)
7214       {
7215          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7216                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7217          break;
7218       }
7219       else
7220       {
7221          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7222          for(int i=0; i< encBufSize; i++)
7223          {
7224             DU_LOG("%x",encBuf[i]);
7225          }
7226       }
7227
7228       measTimingConfigBuf->size = encBufSize;
7229       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7230       if(!measTimingConfigBuf->buf)
7231       {
7232          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7233          break;
7234       }
7235       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7236       ret = ROK;
7237       break;
7238    }
7239    freeMeasuementTimingConfig(measTimingConfig);
7240    return ret;
7241 }
7242
7243 /******************************************************************
7244  *
7245  * @brief Free RRC reconfiguration non-critical extension
7246  *
7247  * @details
7248  *
7249  *    Function : freeRrcReconfigNonCriticalExt
7250  *
7251  *    Functionality: Free RRC reconfiguration non-critical extension
7252  *
7253  * @params[in] RRC reconfiguration IE
7254  * @return void
7255  *
7256  * ****************************************************************/
7257 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7258 {
7259    if(rrcRecfg->masterCellGroup)
7260    {
7261       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7262    }
7263 }
7264
7265 /******************************************************************
7266  *
7267  * @brief Free measurement object addmod list
7268  *
7269  * @details
7270  *
7271  *    Function : freeMeasObjToAddModList
7272  *
7273  *    Functionality: Free measurement object add mod list
7274  *
7275  * @params[in] Measurement object add/mod list
7276  * @return void
7277  *
7278  * ****************************************************************/
7279 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7280 {
7281    uint8_t objIdx;
7282    MeasObjectNR_t *measObject;
7283
7284    if(measObjList->list.array)
7285    {
7286       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7287       {
7288          if(measObjList->list.array[objIdx])
7289          {
7290             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7291             {
7292                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7293                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7294                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7295                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7296                if(measObject->absThreshSS_BlocksConsolidation)
7297                {
7298                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7299                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7300                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7301                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7302                }
7303                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7304                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7305                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7306                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7307                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7308             }
7309             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7310          }
7311       }
7312       CU_FREE(measObjList->list.array, measObjList->list.size);
7313    }
7314 }
7315
7316 /******************************************************************
7317  *
7318  * @brief Free report config add mod list
7319  *
7320  * @details
7321  *
7322  *    Function : freeReportCfgToAddModList
7323  *
7324  *    Functionality: Free report config add mod list
7325  *
7326  * @params[in] Report config list
7327  * @return void
7328  *
7329  * ****************************************************************/
7330 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7331 {
7332    uint8_t reportCfgIdx;
7333    ReportConfigToAddMod_t *reportCfg;
7334    ReportConfigNR_t *reportCfgNr;
7335    EventTriggerConfig_t *eventTriggCfg;
7336
7337    if(reportCfgList->list.array)
7338    {
7339       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7340       {
7341          if(reportCfgList->list.array[reportCfgIdx])
7342          {
7343             reportCfg = reportCfgList->list.array[reportCfgIdx];
7344             if(reportCfg->reportConfig.choice.reportConfigNR)
7345             {
7346                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7347                if(reportCfgNr->reportType.choice.eventTriggered)
7348                {
7349                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7350                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7351                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7352                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7353                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7354                }
7355             }
7356          }
7357          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7358       }
7359       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7360    }
7361 }
7362
7363 /******************************************************************
7364  *
7365  * @brief Free measurement id to add mod list
7366  *
7367  * @details
7368  *
7369  *    Function : freeMeasIdToAddModList
7370  *
7371  *    Functionality: Free measurement id to add mod list
7372  *
7373  * @params[in] Measurement id to add mod list
7374  * @return void
7375  *
7376  * ****************************************************************/
7377 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7378 {
7379    uint8_t measIdIdx;
7380    if(measIdList->list.array)
7381    {
7382       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7383       {
7384          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7385       }
7386       CU_FREE(measIdList->list.array, measIdList->list.size);
7387    }
7388 }
7389
7390 /*******************************************************************
7391  *
7392  * @brief Free quantity config
7393  *
7394  * @details
7395  *
7396  *    Function : freeQunatityConfig
7397  *
7398  *    Functionality: Free quantity config
7399  *
7400  * @params[in] Quantity Config
7401  * @return void
7402  *
7403  * ****************************************************************/
7404 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7405 {
7406    uint8_t quanCfgIdx;
7407    QuantityConfigNR_t *quantityCfgNr;
7408
7409    if(quantityCfg->quantityConfigNR_List)
7410    {
7411       if(quantityCfg->quantityConfigNR_List->list.array)
7412       {
7413          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7414          {
7415             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7416             {
7417                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7418                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7419                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7420                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7421                if(quantityCfgNr->quantityConfigRS_Index)
7422                {
7423                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7424                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7425                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7426                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7427                }
7428                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7429             }
7430          }
7431          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7432       }
7433       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7434    }
7435 }
7436
7437 /******************************************************************
7438  *
7439  * @brief Free measurement Config
7440  *
7441  * @details
7442  *
7443  *    Function : freeMeasConfig
7444  *
7445  *    Functionality: Free measurement config
7446  *
7447  * @params[in] Measurement config
7448  * @return void
7449  *
7450  * ****************************************************************/
7451 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7452 {
7453    if(measConfig->measObjectToAddModList)
7454    {
7455       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7456       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7457    }
7458    if(measConfig->reportConfigToAddModList)
7459    {
7460       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7461       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7462    }
7463    if(measConfig->measIdToAddModList)
7464    {
7465       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7466       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7467    }
7468    if(measConfig->s_MeasureConfig)
7469    {
7470       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7471    }
7472    if(measConfig->quantityConfig)
7473    {
7474       freeQuantityConfig(measConfig->quantityConfig);
7475       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7476    }
7477 }
7478 /******************************************************************
7479  *
7480  * @brief Free DRB to AddMod List
7481  *
7482  * @details
7483  *
7484  *    Function : freeDrbToAddModList
7485  *
7486  *    Functionality: Free SRB to AddMod List
7487  *
7488  * @params[in] SBR to add/mod list
7489  * @return void
7490  *
7491  * ****************************************************************/
7492 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7493 {
7494    uint8_t drbIdx;
7495    if(drbToAddList->list.array)
7496    {
7497       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7498       {
7499          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7500          {
7501             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7502             {
7503                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7504                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7505                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7506                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7507             }
7508             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7509             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7510          }
7511          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7512       }
7513       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7514    }
7515 }
7516
7517 /******************************************************************
7518  *
7519  * @brief Free SRB to AddMod List
7520  *
7521  * @details
7522  *
7523  *    Function : freeSrbToAddModList
7524  *
7525  *    Functionality: Free SRB to AddMod List
7526  *
7527  * @params[in] SBR to add/mod list
7528  * @return void
7529  *
7530  * ****************************************************************/
7531 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7532 {
7533    uint8_t srbIdx;
7534    if(srbToAddList->list.array)
7535    {
7536       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7537       {
7538          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7539          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7540          {
7541             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7542             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7543          }
7544
7545          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7546       }
7547       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7548    }
7549 }
7550
7551 /******************************************************************
7552  *
7553  * @brief Free Radio Bearer Config
7554  *
7555  * @details
7556  *
7557  *    Function : freeRadioBearerConfig
7558  *
7559  *    Functionality: Free Radio Bearer config
7560  *
7561  * @params[in] Radio bearer config
7562  * @return void
7563  *
7564  * ****************************************************************/
7565 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7566 {
7567    if(radioBearerConfig->srb_ToAddModList)
7568    {
7569       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7570       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7571    }
7572    if(radioBearerConfig->drb_ToAddModList)
7573    {
7574       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7575       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7576    }
7577 }
7578
7579 /******************************************************************
7580  *
7581  * @brief Free reconfiguration message
7582  *
7583  * @details
7584  *
7585  *    Function : freeRrcReconfig
7586  *
7587  *    Functionality: Free reconfiguration message
7588  *
7589  * @params[in] RRC Reconfiguration message
7590  * @return void
7591  *
7592  * ****************************************************************/
7593 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7594 {
7595    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7596    {
7597       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7598       {
7599          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7600          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7601       }
7602       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7603       {
7604          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7605          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7606       }
7607       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7608       {
7609          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7610          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7611       }
7612       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7613    }
7614 }
7615
7616 /******************************************************************
7617  *
7618  * @brief Fill SRB To Add Mod list
7619  *
7620  * @details
7621  *
7622  *    Function : fillSrbToAddModList
7623  *
7624  *    Functionality: fill SRB to Add Mod list
7625  *
7626  * @params[in] UE control block
7627  *             SRB to Add/Mod list
7628  * @return ROK     - success
7629  *         RFAILED - failure
7630  *
7631  * ****************************************************************/
7632 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7633 {
7634    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7635
7636    if(updateAllRbCfg)
7637       elementCnt = ueCb->numSrb;
7638    else
7639    {
7640       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7641       {
7642          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7643             elementCnt++;
7644       }
7645    }
7646
7647    if(!elementCnt)
7648    {
7649       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7650       return ROK;
7651    }
7652
7653    srbToAddList->list.count = elementCnt;
7654    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7655
7656    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7657    if(!srbToAddList->list.array)
7658    {
7659       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7660       return RFAILED;
7661    }
7662
7663    srbIdx = 0;
7664    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7665    {
7666       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7667          continue;
7668
7669       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7670       if(!srbToAddList->list.array[srbIdx])
7671       {
7672          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7673          return RFAILED;
7674       }
7675
7676       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7677
7678       /* Reestablish PDCP */
7679       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7680       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7681       {
7682          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7683          return RFAILED;
7684       }
7685       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7686
7687       /* PDCP configuration */
7688       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7689       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7690       {
7691          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7692          return RFAILED;
7693       }
7694
7695       /* Reordering timer */
7696       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7697       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7698       {
7699          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7700          return RFAILED;
7701       }
7702       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7703
7704       srbIdx++;
7705    }
7706    return ROK;
7707 }
7708
7709 /******************************************************************
7710  *
7711  * @biief Fill DRBeTo Add Mod list
7712  *
7713  * @details
7714  *
7715  *    Function : fillDrbToAddModList
7716  *
7717  *    Functionality: fill DRB to Add Mod list
7718  *
7719  * @params[in] UE control block
7720  *             DRB to Add/Mod list
7721  * @return ROK     - success
7722  *         RFAILED - failure
7723  *
7724  * ****************************************************************/
7725 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7726 {
7727    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7728
7729    if(updateAllRbCfg)
7730       elementCnt = ueCb->numDrb;
7731    else
7732    {
7733       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7734       {
7735          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7736             elementCnt++;
7737       }
7738    }
7739
7740    if(!elementCnt)
7741    {
7742       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7743       return ROK;
7744    }
7745
7746
7747    drbToAddList->list.count = elementCnt;
7748    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7749
7750    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7751    if(!drbToAddList->list.array)
7752    {
7753       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7754       return RFAILED;
7755    }
7756
7757    drbIdx = 0;
7758    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7759    {
7760       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7761          continue;
7762
7763       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7764       if(!drbToAddList->list.array[drbIdx])
7765       {
7766          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7767          return RFAILED;
7768       }
7769
7770       /* DRB Id */
7771       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7772
7773       /* PDCP Config */
7774       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7775       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7776       {
7777          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7778          return RFAILED;
7779       }
7780
7781       /* PDCP Config -> DRB */
7782       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7783       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7784       {
7785          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7786          return RFAILED;
7787       }
7788
7789       /* DRB -> Discard Timer */
7790       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7791       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
7792       {
7793          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
7794          return RFAILED;
7795       }
7796       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
7797
7798       /* UL PDCP SN length */
7799       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7800       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
7801       {
7802          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
7803          return RFAILED;
7804       }
7805       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
7806
7807       /* DL PDCP SN length */
7808       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7809       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
7810       {
7811          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
7812          return RFAILED;
7813       }
7814       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
7815
7816       /* Header Compression */
7817       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
7818        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
7819
7820       /* Reordering timer */
7821       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7822       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
7823       {
7824          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
7825          return RFAILED;
7826       }
7827       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7828
7829       drbIdx++;
7830    }
7831
7832    return ROK;
7833 }
7834
7835 /******************************************************************
7836  *
7837  * @brief Fill Radio bearer configuration
7838  *
7839  * @details
7840  *
7841  *    Function : fillRadioBearerConfig
7842  *
7843  *    Functionality: Fill Radio bearer configuration
7844  *
7845  * @params[in] UE control block
7846  *             Radio bearer config pointer
7847  * @return ROK     - success
7848  *         RFAILED - failure
7849  *
7850  * ****************************************************************/
7851 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
7852 {
7853    /* SRB To Add/Mod List */
7854    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7855    if(!radioBearerConfig->srb_ToAddModList)
7856    {
7857       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
7858       return RFAILED;
7859    }
7860    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
7861    {
7862       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
7863       return RFAILED;
7864    }
7865
7866    /* DRB To Add/Mod List */
7867    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7868    if(!radioBearerConfig->drb_ToAddModList)
7869    {
7870       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
7871       return RFAILED;
7872     }
7873    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
7874    {
7875       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
7876       return RFAILED;
7877    }
7878
7879    return ROK;
7880 }
7881
7882 /*******************************************************************
7883  *
7884  * @brief Fill measurement object to add/mod list
7885  *
7886  * @details
7887  *
7888  *    Function : fillMeasObjToAddModList
7889  *
7890  *    Functionality: Fill measurement object to add/mod list
7891  *
7892  * @params[in] Measurement object to add/mod list
7893  * @return ROK     - success
7894  *         RFAILED - failure
7895  *
7896  * ****************************************************************/
7897 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7898 {
7899    uint8_t elementCnt, objIdx;
7900    MeasObjectNR_t *measObject;
7901
7902    elementCnt = 1;
7903    measObjList->list.count = elementCnt;
7904    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
7905
7906    CU_ALLOC(measObjList->list.array, measObjList->list.size);
7907    if(!measObjList->list.array)
7908    {
7909       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
7910       return RFAILED;
7911    }
7912
7913    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7914    {
7915       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7916       if(!measObjList->list.array[objIdx])
7917       {
7918          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
7919          return RFAILED;
7920       }
7921    }
7922
7923    objIdx = 0;
7924    measObjList->list.array[objIdx]->measObjectId = 1;
7925    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
7926    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7927    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7928    {
7929       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
7930       return RFAILED;
7931    }
7932
7933    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7934
7935    /* SSB frequency */
7936    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7937    if(!measObject->ssbFrequency)
7938    {
7939       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
7940       return RFAILED;
7941    }
7942    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
7943
7944    /* Subcarrier spacing */
7945    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7946    if(!measObject->ssbSubcarrierSpacing)
7947    {
7948       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
7949       return RFAILED;
7950    }
7951    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
7952
7953    /* SMTC1 */
7954    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
7955    if(!measObject->smtc1)
7956    {
7957       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
7958       return RFAILED;
7959    }
7960    measObject->smtc1->duration = SSB_MTC__duration_sf1;
7961    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7962    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
7963
7964    /* Absoulute threshold SSB consolidation */
7965    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7966    if(!measObject->absThreshSS_BlocksConsolidation)
7967    {
7968       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
7969       return RFAILED;
7970    }
7971
7972    /* RSRP threshold */
7973    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7974    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
7975    {
7976       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
7977       return RFAILED;
7978    }
7979    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
7980
7981    /* RSRQ threshold */
7982    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7983    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
7984    {
7985       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
7986       return RFAILED;
7987    }
7988    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
7989
7990    /* SINR threshold */
7991    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7992    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
7993    {
7994       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
7995       return RFAILED;
7996    }
7997    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
7998
7999    /* Number of SSBs to average */
8000    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8001    if(!measObject->nrofSS_BlocksToAverage)
8002    {
8003       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8004       return RFAILED;
8005    }
8006    *(measObject->nrofSS_BlocksToAverage) = 2;
8007
8008    /* Quantity Config index */
8009    measObject->quantityConfigIndex = 1;
8010
8011    /* Offset MO */
8012    /* RSRP offset for SSB */
8013    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8014    if(!measObject->offsetMO.rsrpOffsetSSB)
8015    {
8016       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8017       return RFAILED;
8018    }
8019    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8020
8021    /* RSRQ offset for SSB */
8022    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8023    if(!measObject->offsetMO.rsrpOffsetSSB)
8024    {
8025       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8026       return RFAILED;
8027    }
8028    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8029
8030    /* SINR offset for SSB */
8031    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8032    if(!measObject->offsetMO.sinrOffsetSSB)
8033    {
8034       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8035       return RFAILED;
8036    }
8037    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8038
8039    return ROK;
8040 }
8041
8042 /*******************************************************************
8043  *
8044  * @brief Fill Report configuration to Add/mod list
8045  *
8046  * @details
8047  *
8048  *    Function : fillReportCfgToAddModList
8049  *
8050  *    Functionality: Fill Report configuration to Add/mod list
8051  *
8052  * @params[in] Report Config To Add/Mod List
8053  * @return ROK     - success
8054  *         RFAILED - failure
8055  *
8056  * ****************************************************************/
8057 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8058 {
8059    uint8_t elementCnt;
8060    uint8_t reportCfgIdx;
8061    ReportConfigToAddMod_t *reportCfg;
8062    ReportConfigNR_t *reportCfgNr;
8063    EventTriggerConfig_t *eventTriggCfg;
8064
8065    elementCnt = 1;
8066    reportCfgList->list.count = elementCnt;
8067    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8068
8069    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8070    if(!reportCfgList->list.array)
8071    {
8072       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8073       return RFAILED;
8074    }
8075
8076    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8077    {
8078       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8079       if(!reportCfgList->list.array[reportCfgIdx])
8080       {
8081          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8082          return RFAILED;
8083       }
8084    }
8085
8086    reportCfgIdx = 0;
8087    reportCfg = reportCfgList->list.array[reportCfgIdx];
8088    reportCfg->reportConfigId = 1;
8089    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8090
8091    /* Report Configuration for NR */
8092    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8093    if(!reportCfg->reportConfig.choice.reportConfigNR)
8094    {
8095       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8096       return RFAILED;
8097    }
8098    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8099
8100    /* Report Type */
8101    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8102    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8103    if(!reportCfgNr->reportType.choice.eventTriggered)
8104    {
8105       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8106       return RFAILED;
8107    }
8108    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8109
8110    /* Event 3 */
8111    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8112    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8113    if(!eventTriggCfg->eventId.choice.eventA3)
8114    {
8115       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8116       return RFAILED;
8117    }
8118
8119    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8120    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8121    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8122    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8123    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8124    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8125
8126    /* Reference Signal Type */
8127    eventTriggCfg->rsType = NR_RS_Type_ssb;
8128
8129    /* Report Interval */
8130    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8131
8132    /* Report Amount */
8133    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8134
8135    /* Report Quantity cell */
8136    eventTriggCfg->reportQuantityCell.rsrp = true;
8137    eventTriggCfg->reportQuantityCell.rsrq = false;
8138    eventTriggCfg->reportQuantityCell.sinr = false;
8139
8140    /* Maximum reported cells */
8141    eventTriggCfg->maxReportCells = 3;
8142
8143    /* Report qunatity RS Indexes */
8144    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8145    if(!eventTriggCfg->reportQuantityRS_Indexes)
8146    {
8147       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8148       return RFAILED;
8149    }
8150    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8151    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8152    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8153
8154    /* Maximum number of RS indexes to report */
8155    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8156    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8157    {
8158       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8159       return RFAILED;
8160    }
8161    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8162
8163    /* Include Beam measurement */
8164    eventTriggCfg->includeBeamMeasurements = false;
8165
8166    return ROK;
8167 }
8168
8169 /*******************************************************************
8170  *
8171  * @brief Fill measurement Id to add/mod list
8172
8173  * @details
8174  *
8175  *    Function : fillMeasIdToAddModList
8176  *
8177  *    Functionality: Fill measurement Id to add/mod list
8178  *
8179  * @params[in] Measurement Id to add/mod list
8180  * @return ROK     - success
8181  *         RFAILED - failure
8182  *
8183  * ****************************************************************/
8184 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8185 {
8186    uint8_t elementCnt;
8187    uint8_t measIdIdx;
8188
8189    elementCnt = 1;
8190    measIdList->list.count = elementCnt;
8191    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8192
8193    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8194    if(!measIdList->list.array)
8195    {
8196       return RFAILED;
8197    }
8198
8199    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8200    {
8201       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8202       if(!measIdList->list.array[measIdIdx])
8203       {
8204          return RFAILED;
8205       }
8206
8207       measIdIdx=0;
8208       measIdList->list.array[measIdIdx]->measId = 1;
8209       measIdList->list.array[measIdIdx]->measObjectId = 1;
8210       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8211    }
8212    return ROK;
8213 }
8214
8215 /*******************************************************************
8216  *
8217  * @brief Fill s-measurement configuration
8218  *
8219  * @details
8220  *
8221  *    Function : fillSMeasConfig
8222  *
8223  *    Functionality: Fill s-measurement configuration
8224  *
8225  * @params[in] s-Measurement config
8226  * @return ROK     - success
8227  *         RFAILED - failure
8228  *
8229  * ****************************************************************/
8230 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8231 {
8232    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8233    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8234
8235    return ROK;
8236 }
8237
8238 /*******************************************************************
8239  *
8240  * @brief Fill quantity config
8241  *
8242  * @details
8243  *
8244  *    Function : fillQunatityConfig
8245  *
8246  *    Functionality: Fill quantity config
8247  *
8248  * @params[in] Quantity Config
8249  * @return ROK     - success
8250  *         RFAILED - failure
8251  *
8252  * ****************************************************************/
8253 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8254 {
8255    uint8_t elementCnt = 0;
8256    uint8_t quanCfgIdx = 0;
8257    QuantityConfigNR_t *quantityCfgNr;
8258
8259    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8260    if(!quantityCfg->quantityConfigNR_List)
8261    {
8262       return RFAILED;
8263    }
8264
8265    elementCnt = 1;
8266    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8267    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8268
8269    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8270    if(!quantityCfg->quantityConfigNR_List->list.array)
8271    {
8272       return RFAILED;
8273    }
8274
8275    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8276    {
8277       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8278       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8279       {
8280          return RFAILED;
8281       }
8282    }
8283
8284    quanCfgIdx = 0;
8285    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8286
8287    /* Quantity Config of Reference signal */
8288    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8289    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8290    {
8291       return RFAILED;
8292    }
8293    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8294
8295    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8296    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8297    {
8298       return RFAILED;
8299    }
8300    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8301
8302    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8303    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8304    {
8305       return RFAILED;
8306    }
8307    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8308
8309    /* Quantity Config RS index */
8310    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8311    if(!quantityCfgNr->quantityConfigRS_Index)
8312    {
8313       return RFAILED;
8314    }
8315
8316    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8317    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8318    {
8319       return RFAILED;
8320    }
8321    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8322
8323    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8324    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8325    {
8326       return RFAILED;
8327    }
8328    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8329
8330    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8331    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8332    {
8333       return RFAILED;
8334    }
8335    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8336
8337    return ROK;
8338 }
8339
8340 /*******************************************************************
8341  *
8342  * @brief Fill measurement configuration
8343  *
8344  * @details
8345  *
8346  *    Function : fillMeasConfig
8347  *
8348  *    Functionality: Fill measurement configuration
8349  *
8350  * @params[in] Measurement config
8351  * @return ROK     - success
8352  *         RFAILED - failure
8353  *
8354  * ****************************************************************/
8355 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8356 {
8357    /* Measurement object to add/mod list */
8358    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8359    if(!measConfig->measObjectToAddModList)
8360    {
8361       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8362       return RFAILED;
8363    }
8364    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8365    {
8366       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8367       return RFAILED;
8368    }
8369
8370    /* Report Config To add/mod list */
8371    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8372    if(!measConfig->reportConfigToAddModList)
8373    {
8374       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8375       return RFAILED;
8376    }
8377    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8378    {
8379       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8380       return RFAILED;
8381    }
8382
8383    /* Measurement Id to add/mod list */
8384    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8385    if(!measConfig->measIdToAddModList)
8386    {
8387       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8388       return RFAILED;
8389    }
8390    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8391    {
8392       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8393       return RFAILED;
8394    }
8395
8396    /* S-Measurement config */
8397    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8398    if(!measConfig->s_MeasureConfig)
8399    {
8400       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8401       return RFAILED;
8402    }
8403    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8404    {
8405       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8406       return RFAILED;
8407    }
8408
8409    /* Qunatity Config */
8410    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8411    if(!measConfig->quantityConfig)
8412    {
8413       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8414       return RFAILED;
8415    }
8416    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8417    {
8418       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8419       return RFAILED;
8420    }
8421
8422 return ROK;
8423 }
8424
8425 /*******************************************************************
8426  *
8427  * @brief Fill RRC reconfiguration non-critical extension IE
8428  *
8429  * @details
8430  *
8431  *    Function : fillRrcReconfigNonCriticalExt
8432  *
8433  *    Functionality: Fill RRC reconfiguration non-critical extension
8434  *
8435  * @params[in] RRC Reconfig Non-critical extension
8436  * @return ROK     - success
8437  *         RFAILED - failure
8438  *
8439  * ****************************************************************/
8440 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8441 {
8442    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8443    if(!rrcRecfg->masterCellGroup)
8444    {
8445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8446       return RFAILED;
8447    }
8448
8449    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8450    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8451    if(!rrcRecfg->masterCellGroup->buf)
8452    {
8453       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8454       return RFAILED;
8455    }
8456    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8457
8458 #if 0
8459    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8460     * received from DU */
8461    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8462    {
8463       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8464       return RFAILED;
8465    }
8466 #endif
8467
8468    return ROK;
8469 }
8470
8471 /*******************************************************************
8472  *
8473  * @brief Fill RRC reconfiguration structure
8474  *
8475  * @details
8476  *
8477  *    Function : fillRrcReconfig
8478  *
8479  *    Functionality: Fill RRC reconfiguration
8480
8481  *
8482  * @params[in] UE Cb
8483  *             RRC reconfiguration structure
8484  * @return ROK     - success
8485  *         RFAILED - failure
8486  *
8487  * ****************************************************************/
8488 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8489 {
8490    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8491
8492    rrcReconfig->rrc_TransactionIdentifier = 1;
8493    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8494
8495    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8496    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8497    {
8498       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8499       return RFAILED;
8500    }
8501
8502    /* Radio Bearer Configuration */
8503    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8504    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8505    {
8506       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8507       return RFAILED;
8508    }
8509    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8510    {
8511       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8512       return RFAILED;
8513    }
8514
8515    /* Measurement Configuration */
8516    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8517    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8518    {
8519       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8520       return RFAILED;
8521    }
8522    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8523    {
8524       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8525       return RFAILED;
8526    }
8527
8528    /* Non Critical extension */
8529    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8530    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8531    {
8532       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8533       return RFAILED;
8534    }
8535    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8536    {
8537       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8538       return RFAILED;
8539    }
8540    return ROK;
8541 }
8542
8543 /*******************************************************************
8544  *
8545  * @brief Fill RRC reconfiguration Octet string
8546  *
8547  * @details
8548  *
8549  *    Function : fillRrcReconfigBuf
8550  *
8551  *    Functionality: Fill RRC reconfiguration octet string
8552
8553  *
8554  * @params[in] OCTET_STRING_t buffer
8555  * @return ROK     - success
8556  *         RFAILED - failure
8557  *
8558  * ****************************************************************/
8559 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8560 {
8561    uint8_t          ret = RFAILED;
8562    asn_enc_rval_t   encRetVal;
8563    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8564    rrcReconfig = &rrcRecfg;
8565
8566    while(true)
8567    {
8568       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8569       {
8570          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8571          break;
8572       }
8573
8574       /* Encode RRC Reconfiguration */
8575       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8576       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8577       encBufSize = 0;
8578       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8579
8580       /* Encode results */
8581       if(encRetVal.encoded == ENCODE_FAIL)
8582       {
8583          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8584                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8585          break;
8586       }
8587       else
8588       {
8589          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8590          for(int i=0; i< encBufSize; i++)
8591          {
8592             DU_LOG("%x",encBuf[i]);
8593          }
8594       }
8595
8596       rrcReconfigBuf->size = encBufSize;
8597       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8598       if(!rrcReconfigBuf->buf)
8599       {
8600          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8601          break;
8602       }
8603       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8604       ret = ROK;
8605       break;
8606    }
8607
8608    freeRrcReconfig(rrcReconfig);
8609    return ret;
8610 }
8611
8612 /*******************************************************************
8613  *
8614  * @brief Fill HO preparation information Octet string
8615  *
8616  * @details
8617  *
8618  *    Function : fillHOPreparationInfoBuf
8619  *
8620  *    Functionality: Fill HO preparation information Octet string
8621
8622  *
8623  * @params[in] HandoverPreparationInformation_t buffer
8624  * @return ROK     - success
8625  *         RFAILED - failure
8626  *
8627  * ****************************************************************/
8628 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8629 {
8630    uint8_t          ret = RFAILED;
8631    asn_enc_rval_t   encRetVal;
8632    HandoverPreparationInformationRrc_t hoPrepInfo;
8633    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8634
8635    while(true)
8636    {
8637
8638       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8639       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8640       if(!hoPrepInfo.criticalExtensions.choice.c1)
8641       {
8642          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8643          break;
8644       }
8645       hoPrepInfo.criticalExtensions.choice.c1->present = \
8646          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8647
8648       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8649          sizeof(HandoverPreparationInformationRrc_IEs_t));
8650       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8651       {
8652          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8653          break;
8654       }
8655       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8656
8657       /* Fill UE Capability RAT container list */
8658       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8659       if(ret != ROK)
8660       {
8661          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8662          break;
8663       }
8664
8665       /* Fill Source config */
8666       hoPrepInfoIe->sourceConfig = NULLP;
8667       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8668       if(!hoPrepInfoIe->sourceConfig)
8669       {
8670          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8671          return RFAILED;
8672       }
8673       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8674
8675       if(ret != ROK)
8676       {
8677          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8678          return RFAILED;
8679       }
8680
8681       hoPrepInfoIe->rrm_Config = NULLP;
8682       hoPrepInfoIe->as_Context = NULLP;
8683       hoPrepInfoIe->nonCriticalExtension = NULLP;
8684
8685       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8686       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8687       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8688       encBufSize = 0;
8689       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8690             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8691
8692       /* Encode results */
8693       if(encRetVal.encoded == ENCODE_FAIL)
8694       {
8695          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8696                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8697          break;
8698       }
8699       else
8700       {
8701          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8702          for(int i=0; i< encBufSize; i++)
8703          {
8704             DU_LOG("%x",encBuf[i]);
8705          }
8706       }
8707
8708       hoPrepInfoBuf->size = encBufSize;
8709       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8710       if(!hoPrepInfoBuf->buf)
8711       {
8712          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8713          break;
8714       }
8715       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8716       ret = ROK;
8717       break;
8718    }
8719    freeHOPreparationInfo(&hoPrepInfo);
8720    return ret;
8721 }
8722
8723 /*******************************************************************
8724  *
8725  * @brief Fills CuToDuContainer
8726  *
8727  * @details
8728  *
8729  *    Function : fillCuToDuContainer
8730  *
8731  *    Functionality: Fills CuToDuContainer
8732  *
8733  * @params[in] pointer to CUtoDURRCInformation_t
8734  *
8735  * @return ROK     - success
8736  *         RFAILED - failure
8737  *
8738  ******************************************************************/
8739
8740 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8741 {
8742    uint8_t elementCnt = 0;
8743    uint8_t ret = ROK;
8744    uint8_t idx, idx2, rrcBufLen;
8745
8746    /* UE Capabulity RAT Container List */
8747    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8748    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8749    {
8750       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8751       return RFAILED;
8752    }
8753    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8754
8755    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8756    if(!rrcMsg->measConfig)
8757    {
8758       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8759       return RFAILED;
8760    }
8761    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8762
8763    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8764    {
8765       /* IE extensions */
8766       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8767       if(rrcMsg->iE_Extensions)
8768       {
8769          elementCnt = 1;
8770          rrcMsg->iE_Extensions->list.count = elementCnt;
8771          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8772
8773          /* Initialize the CUtoDURRCInformation_ExtIEs */
8774          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8775
8776          if(rrcMsg->iE_Extensions->list.array == NULLP)
8777          {
8778             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8779             ret = RFAILED;
8780          }
8781
8782          for(idx=0; idx<elementCnt; idx++)
8783          {
8784             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8785             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8786             {
8787                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8788                ret = RFAILED;
8789             }
8790          }
8791
8792          idx = 0;
8793 #if 0
8794          /* Cell Group Configuration */
8795          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
8796          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8797          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
8798                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
8799          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
8800          idx++;
8801 #endif
8802          /* Handover Preparation Information */
8803          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
8804          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8805          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
8806                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
8807          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
8808       }
8809    }
8810    return ret;
8811 }
8812
8813 /*******************************************************************
8814  *
8815  * @brief Free CuToDuContainer
8816  *
8817  * @details
8818  *
8819  *    Function : FreeCuToDuInfo
8820  *
8821  *    Functionality: Free CuToDuContainer
8822  *
8823  * @params[in] pointer to CUtoDURRCInformation_t
8824  *
8825  * @return ROK     - success
8826  *         RFAILED - failure
8827  *
8828  ******************************************************************/
8829
8830 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8831 {
8832    uint8_t idx, idx2;
8833
8834    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8835    {
8836       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8837          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
8838       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8839    }
8840    if(rrcMsg->iE_Extensions)
8841    {
8842       if(rrcMsg->iE_Extensions->list.array)
8843       {
8844          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
8845          {
8846             if(rrcMsg->iE_Extensions->list.array[idx])
8847             {
8848                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
8849                {
8850                   case ProtocolIE_ID_id_CellGroupConfig:
8851                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8852                      {
8853                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
8854                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
8855
8856                      }
8857                      break;
8858                   default:
8859                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8860                            rrcMsg->iE_Extensions->list.array[idx]->id);
8861                      break;
8862                }
8863             }
8864             break;
8865          }
8866          for(idx2 = 0; idx2 < idx; idx2++)
8867          {
8868             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
8869          }
8870          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8871
8872       }
8873
8874       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8875    }
8876 }
8877 /*******************************************************************
8878  *
8879  * @brief Builds and sends the UE Setup Request
8880  *
8881  * @details
8882  *
8883  *    Function : BuildAndSendUeContextSetupReq
8884  *
8885  *    Functionality: Constructs the UE Setup Request and sends
8886  *                   it to the CU through SCTP.
8887  *
8888  * @params[in]
8889  *
8890  * @return ROK     - success
8891  *         RFAILED - failure
8892  *
8893  * ****************************************************************/
8894 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
8895 {
8896    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
8897    uint8_t   ret= RFAILED, ret1;
8898    uint8_t   elementCnt;
8899    uint8_t   idx, idx1, bufLen, duIdx;
8900    uint32_t  spCellId;
8901    DuDb      *targetDuDb = NULLP;
8902    F1AP_PDU_t           *f1apMsg = NULLP;
8903    UEContextSetupRequest_t *ueSetReq = NULLP;
8904    asn_enc_rval_t encRetVal;        /* Encoder return value */
8905    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8906
8907    while(true)
8908    {
8909       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
8910
8911       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8912       if(f1apMsg == NULLP)
8913       {
8914          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8915          break;
8916       }
8917
8918       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8919       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8920       if(f1apMsg->choice.initiatingMessage == NULLP)
8921       {
8922          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
8923          break;
8924       }
8925
8926       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
8927       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8928       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
8929
8930       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
8931
8932       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8933          elementCnt = 7;
8934       else
8935          elementCnt = 11;
8936       ueSetReq->protocolIEs.list.count = elementCnt;
8937       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
8938
8939       /* Initialize the UESetup members */
8940       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
8941
8942       if(ueSetReq->protocolIEs.list.array == NULLP)
8943       {
8944          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
8945          break;
8946       }
8947
8948       for(idx1=0; idx1<elementCnt; idx1++)
8949       {
8950          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
8951          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
8952          {
8953             break;
8954          }
8955       }
8956
8957       idx = 0;
8958
8959       /*GNB CU UE F1AP ID*/
8960       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8961       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8962       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8963       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
8964
8965       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8966       {
8967          /*GNB DU UE F1AP ID*/
8968          idx++;
8969          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8970          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8971          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8972          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
8973       }
8974
8975       /*Special Cell ID*/
8976       idx++;
8977       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
8978       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8979       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
8980       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8981       {
8982          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
8983          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
8984          /* Since we are supporting only one cell per DU, accessing 0th index to
8985           * get target cell info */
8986          spCellId = targetDuDb->cellCb[0].nrCellId;
8987       }
8988       else
8989          spCellId = ueCb->cellCb->nrCellId;
8990       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
8991       if(Nrcgiret != ROK)
8992       {
8993          break;
8994       }
8995
8996       /*Served Cell Index*/
8997       idx++;
8998       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
8999       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9000       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9001       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9002
9003       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9004       {
9005          /*CellULConfigured*/
9006          idx++;
9007          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9008          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9009          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9010          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9011       }
9012
9013       /*CUtoDURRCContainer*/
9014       idx++;
9015       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9016       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9017       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9018       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9019       {
9020          break;
9021       }
9022
9023       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9024       {
9025          /*Special Cells to be SetupList*/
9026          idx++;
9027          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9028          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9029          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9030          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9031          if(SplCellListret != ROK)
9032          {
9033             break;
9034          }
9035       }
9036
9037       /*SRBs To Be Setup List*/
9038       idx++;
9039       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9040       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9041       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9042       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9043       if(SrbSetupret != ROK)
9044       {
9045          break;
9046       }
9047
9048       /*DRBs to Be Setup List*/
9049       idx++;
9050       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9051       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9052       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9053       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9054       if(ret1 != ROK)
9055       {
9056          break;
9057       }
9058
9059       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9060       {
9061          /* RRC delivery status request */
9062          idx++;
9063          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9064          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9065          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9066          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9067       }
9068
9069       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9070       idx++;
9071       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9072       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9073       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9074
9075       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9076       bufLen = 4;
9077       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9078       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9079             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9080       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9081       {
9082          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9083          break;
9084       }
9085       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9086       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9087
9088       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9089
9090       /* Encode the F1SetupRequest type as APER */
9091       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9092       encBufSize = 0;
9093       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9094
9095       /* Encode results */
9096       if(encRetVal.encoded == ENCODE_FAIL)
9097       {
9098          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9099                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9100          break;
9101       }
9102       else
9103       {
9104          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9105          for(int i=0; i< encBufSize; i++)
9106          {
9107             DU_LOG("%x",encBuf[i]);
9108          }
9109       }
9110
9111       /* Sending  msg  */
9112       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9113       {
9114          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9115          break;
9116       }
9117       ret = ROK;
9118       break;
9119    }
9120    FreeUeContextSetupReq(f1apMsg);
9121
9122    return ret;
9123 }/* End of BuildAndSendUeContextSetupReq*/
9124
9125 /**********************************************************************
9126  * @brief Function to extractTeId received in UE context setup Response
9127  *
9128  * @details
9129  *
9130  *    Function : extractTeId
9131  *
9132  *    Functionality:
9133  *         - Function to extract TeId
9134  *
9135  * @params[in]
9136  * @return ROK     - success
9137  *         RFAILED - failure
9138  *
9139  **********************************************************************/
9140 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9141 {
9142    uint8_t arrIdx = 0;
9143    uint32_t teId = 0;
9144    GTPTunnel_t *gtpDl = NULLP;
9145
9146    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9147    {
9148       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9149       {
9150          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9151          {
9152             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9153             if(gtpDl->gTP_TEID.size > 0)
9154             {
9155                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9156             }
9157             else
9158                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9159             return(teId);
9160          }
9161       }
9162    }
9163    return teId;
9164 }
9165
9166 /****************************************************************
9167  * @brief Function to add Drb tunnels
9168  *
9169  * @details
9170  *
9171  *    Function : addDrbTunnels
9172  *
9173  *    Functionality:
9174  *         - Function to add Drb tunnels
9175  *
9176  * @params[in]
9177  * @return ROK     - success
9178  *         RFAILED - failure
9179  *
9180  * ****************************************************************/
9181 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9182 {
9183    uint8_t ret = ROK;
9184    EgtpTnlEvt tnlEvt;
9185
9186    if(teId > MAX_TEID || teId < MIN_TEID)
9187    {
9188       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9189    }
9190    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9191    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9192    tnlEvt.lclTeid = teId;
9193    tnlEvt.remTeid = teId;
9194    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9195    if(ret != ROK)
9196    {
9197       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9198    }
9199    return ROK;
9200 }
9201
9202 /****************************************************************
9203  * @brief Function to process Drb Setup List
9204  *
9205  * @details
9206  *
9207  *    Function : procDrbSetupList
9208  *
9209  *    Functionality:
9210  *         - Function to process DRB Setup List
9211  *
9212  * @params[in]
9213  * @return ROK     - success
9214  *         RFAILED - failure
9215  *
9216  * ****************************************************************/
9217 uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList)
9218 {
9219    uint8_t arrIdx = 0;
9220    uint32_t teId = 0;
9221    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9222
9223    if(drbSetupList != NULLP)
9224    {
9225       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9226       {
9227          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9228          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9229          {
9230             /* extracting teId */
9231             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9232             if(teId > 0)
9233             {
9234               if(addDrbTunnels(duId, teId)== ROK)
9235               {
9236                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9237               }
9238             }
9239             else
9240                return RFAILED;
9241          }
9242       }
9243    }
9244    return ROK;
9245 }
9246
9247 /****************************************************************
9248  * @brief Function to process Ue Context Setup Response
9249  *
9250  * @details
9251  *
9252  *    Function : procUeContextSetupResponse
9253  *
9254  *    Functionality:
9255  *         - Function to process Ue Context Setup Response
9256  *
9257  * @params[in]
9258  * @return ROK     - success
9259  *         RFAILED - failure
9260  *
9261  * ****************************************************************/
9262 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9263 {
9264    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9265    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9266    DuDb *duDb = NULLP;
9267    CuUeCb *ueCb = NULLP;
9268    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9269    OCTET_STRING_t *duToCuRrcContainer;
9270
9271    SEARCH_DU_DB(duIdx, duId, duDb);
9272    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9273
9274    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9275    {
9276       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9277       {
9278           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9279              {
9280                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9281                break;
9282              }
9283           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9284              {
9285                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9286                 ueCb = &duDb->ueCb[duUeF1apId-1];
9287                 /* If ue context is not present in du db, then create UE context
9288                  * here. This flow is hit in case of UE handover where UE
9289                  * context is created before UE performs RACH on target DU */
9290                 if(ueCb->gnbDuUeF1apId == 0)
9291                 {
9292                    /* Creating UE context in target DU */
9293                    memset(ueCb, 0, sizeof(CuUeCb));
9294                    ueCb->cellCb = &duDb->cellCb[0];
9295                    ueCb->gnbDuUeF1apId = duUeF1apId;
9296                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9297                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9298                    ueCb->hoInfo.targetDuId = duId;
9299                    (duDb->numUe)++;
9300
9301                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9302                    ueCb->cellCb->numUe++;
9303                 }
9304                 break;
9305              }
9306           case ProtocolIE_ID_id_C_RNTI:
9307              {
9308                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9309                 break;
9310              }
9311           case ProtocolIE_ID_id_DRBs_Setup_List:
9312              {
9313                 /* Adding Tunnels for successful DRB */
9314                 procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9315                 break;
9316              }
9317          case ProtocolIE_ID_id_DUtoCURRCInformation:
9318              {
9319                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9320                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9321                    DUtoCURRCInformation.cellGroupConfig;
9322                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9323                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9324                 {
9325                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9326                    return RFAILED;
9327                 }
9328                 break;
9329              }
9330       }
9331    }
9332
9333    /* If the UE is in handover, UE context modification request is to be sent to
9334     * source DU once UE context setup response is received from target DU */
9335    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9336    {
9337       DuDb *srcDuDb = NULLP;
9338       CuUeCb *ueCbInSrcDu = NULLP;
9339
9340       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9341        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9342       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9343       {
9344          /* UE context setup response is received from target DU. Search all
9345           * DUs to find source DU except this target DU Id.*/
9346          if(cuCb.duInfo[duIdx].duId != duId)
9347          {
9348             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9349             {
9350                /* Check following:
9351                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9352                 * received in UE context setup response since CU UE F1AP ID does not
9353                 * change for UE in handover.
9354                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9355                 */
9356                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9357                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9358                {
9359                   srcDuDb = &cuCb.duInfo[duIdx];
9360                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9361
9362                   /* Store source DU info in the new UE context created in
9363                    * tareget DU */
9364                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9365
9366                   /* Copy the received container to UeCb */
9367                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9368
9369                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9370                   {
9371                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9372                      return RFAILED;
9373                   }
9374                   break;
9375                }
9376             }
9377          }
9378          if(srcDuDb && ueCbInSrcDu)
9379             break;
9380       }
9381    }
9382    else
9383    {
9384       ueCb->f1apMsgDb.dlRrcMsgCount++;
9385       rrcMsgType = setDlRRCMsgType(ueCb);
9386
9387       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9388       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9389       {
9390          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9391          return RFAILED;
9392       }
9393    }
9394
9395    return ROK;
9396 }
9397
9398 /****************************************************************
9399  * @brief Function to process Ul Rrc Msg received from DU
9400  *
9401  * @details
9402  *
9403  *    Function : procUlRrcMsg
9404  *
9405  *    Functionality:
9406  *         - Function to process Ul Rrc Msg received from DU
9407  *
9408  * @params[in]
9409  * @return ROK     - success
9410  *         RFAILED - failure
9411  *
9412  * ****************************************************************/
9413
9414 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9415 {
9416    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9417    uint8_t  *rrcContainer = NULLP;
9418    uint16_t rrcContLen = 0;
9419    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9420    DuDb     *duDb = NULLP;
9421    CuUeCb   *ueCb = NULLP;
9422    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9423
9424    ret = ROK;
9425    SEARCH_DU_DB(duIdx, duId, duDb);
9426    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9427
9428    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9429    {
9430       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9431       {
9432          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9433             {
9434                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9435                break;
9436             }
9437          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9438             {
9439                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9440                break;
9441             }
9442          case ProtocolIE_ID_id_SRBID:
9443             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9444             break;
9445
9446          case ProtocolIE_ID_id_RRCContainer:
9447             {
9448                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9449                CU_ALLOC(rrcContainer, rrcContLen);
9450                if(!rrcContainer)
9451                {
9452                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9453                   return RFAILED;
9454                }
9455                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9456
9457                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9458                {
9459                   uint8_t ueIdx = 0;
9460                   uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.sourceDuId;
9461                   DuDb *srcDuDb = NULLP;
9462
9463                   /* In target DU DB, mark UE as active and delete HO info */
9464                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9465                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9466
9467                   /* Release UE context in source DU because the UE is now
9468                    * attached to target DU */
9469                   SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9470                   for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9471                   {
9472                      if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9473                      {
9474                         ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9475                         if(ret != ROK)
9476                         {
9477                            DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9478                         }
9479                         break;
9480                      }
9481                   }
9482                   return ret;
9483                }
9484                break;
9485             }
9486
9487          default:
9488             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9489             break;
9490       }
9491    }
9492
9493    if(srbId == 1)
9494    {
9495       ueCb = &duDb->ueCb[duUeF1apId-1];
9496       ueCb->f1apMsgDb.dlRrcMsgCount++;
9497       rrcMsgType = setDlRRCMsgType(ueCb);
9498       if(rrcMsgType == RRC_SETUP_COMPLETE)
9499       {
9500          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for Security Mode Command");
9501          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9502       }
9503       else if(rrcMsgType == SECURITY_MODE_COMPLETE)
9504       {
9505          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9506          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9507       }
9508       else if(rrcMsgType == REGISTRATION_COMPLETE)
9509       {
9510          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9511          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9512       }
9513       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9514       {
9515          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9516          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9517       }
9518    }
9519    return ret;
9520 }
9521
9522 /****************************************************************
9523  * @brief Build And Send F1ResetAck
9524  *
9525  * @details
9526  *
9527  *    Function : FreeF1ResetAck
9528  *
9529  *    Functionality:
9530  *         - Build And Send  F1ResetRSP
9531  *
9532  *  @params[in]
9533  * @return ROK     - success
9534  *         RFAILED - failure
9535  *
9536  * ****************************************************************/
9537 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9538 {
9539    uint8_t idx;
9540    ResetAcknowledge_t *f1ResetAck;
9541
9542    if(f1apMsg)
9543    {
9544       if(f1apMsg->choice.successfulOutcome)
9545       {
9546          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9547
9548          if(f1ResetAck->protocolIEs.list.array)
9549          {
9550             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9551             {
9552                if(f1ResetAck->protocolIEs.list.array[idx])
9553                {
9554                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9555                }
9556             }
9557             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9558          }
9559          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9560       }
9561       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9562    }
9563 }
9564
9565 /****************************************************************
9566  * @brief Build And Send F1ResetAck
9567  *
9568  * @details
9569  *
9570  *    Function : BuildAndSendF1ResetAck
9571  *
9572  *    Functionality:
9573  *         - Build And Send  F1ResetRSP
9574  *
9575  *  @params[in]
9576  * @return ROK     - success
9577  *         RFAILED - failure
9578  *
9579  * ****************************************************************/
9580
9581 uint8_t BuildAndSendF1ResetAck()
9582 {
9583    uint8_t                idx = 0;
9584    uint8_t                elementCnt = 0;
9585    uint8_t                ret = RFAILED;
9586    F1AP_PDU_t             *f1apMsg = NULL;
9587    ResetAcknowledge_t     *f1ResetAck = NULLP;
9588    asn_enc_rval_t         encRetVal;
9589    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9590
9591    do{
9592       /* Allocate the memory for F1ResetRequest_t */
9593       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9594       if(f1apMsg == NULLP)
9595       {
9596          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9597          break;
9598       }
9599
9600       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9601
9602       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9603       if(f1apMsg->choice.successfulOutcome == NULLP)
9604       {
9605          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9606          break;
9607       }
9608
9609       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9610       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9611       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9612       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9613
9614       elementCnt = 1;
9615
9616       f1ResetAck->protocolIEs.list.count = elementCnt;
9617       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9618
9619       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9620       if(f1ResetAck->protocolIEs.list.array == NULLP)
9621       {
9622          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9623          break;
9624       }
9625
9626       for(idx=0; idx<elementCnt; idx++)
9627       {
9628          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9629          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9630          {
9631             break;
9632          }
9633       }
9634       /*TransactionID*/
9635       idx = 0;
9636       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9637       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9638       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9639       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9640
9641       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9642
9643       /* Encode the F1SetupRequest type as UPER */
9644       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9645       encBufSize = 0;
9646       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9647
9648       /* Check encode results */
9649       if(encRetVal.encoded == ENCODE_FAIL)
9650       {
9651          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9652                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9653          break;
9654       }
9655       else
9656       {
9657          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9658          for(int i=0; i< encBufSize; i++)
9659          {
9660             DU_LOG("%x",encBuf[i]);
9661          }
9662       }
9663
9664       /* Sending msg */
9665       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9666       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9667       {
9668          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9669          break;
9670       }
9671
9672       ret = ROK;
9673       break;
9674    }while(true);
9675
9676    FreeF1ResetAck(f1apMsg);
9677    return ret;
9678 }
9679
9680 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9681 {
9682    uint8_t arrIdx =0;
9683
9684    if(ulInfo->list.array)
9685    {
9686       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9687       {
9688          if(ulInfo->list.array[arrIdx])
9689          {
9690             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9691             {
9692                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9693                {
9694                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9695                   {
9696                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9697                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9698                      gTPTunnel->gTP_TEID.size);
9699                   }
9700                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9701                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9702                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9703                }
9704                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9705                sizeof(GTPTunnel_t));
9706             }
9707             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9708          }
9709       }
9710       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9711    }
9712 }
9713
9714 /*******************************************************************
9715 *
9716 * @brief Deletes the EGTP tunnel
9717 *
9718 * @details
9719 *
9720 *    Function : deleteEgtpTunnel
9721 *
9722 *    Functionality: Deletes the EGTP tunnel
9723 *
9724 * @params[in] uint8_t *buf
9725 *
9726 * @return ROK     - success
9727 *         RFAILED - failure
9728 *
9729 * ****************************************************************/
9730 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
9731 {
9732    uint32_t teId = 0;
9733    EgtpTnlEvt tnlEvt;
9734
9735    teIdStringToInt(buf, &teId);
9736    if(teId > MAX_TEID || teId < MIN_TEID)
9737    {
9738       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
9739       return RFAILED;
9740    }
9741    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9742    tnlEvt.action = EGTP_TNL_MGMT_DEL;
9743    tnlEvt.lclTeid = teId;
9744    tnlEvt.remTeid = teId;
9745    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
9746    {
9747       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
9748    }
9749    return ROK;
9750 }
9751
9752 /*******************************************************************
9753 *
9754 * @brief Builds the Uplink Tunnel Info
9755 *
9756 * @details
9757 *
9758 *    Function : BuildUlTnlInfoforSetupMod
9759 *
9760 *    Functionality: Constructs the UL TnlInfo For DRB list
9761 *
9762 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9763 *
9764 * @return ROK     - success
9765 *         RFAILED - failure
9766 *
9767 * ****************************************************************/
9768 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
9769 {
9770    uint8_t arrIdx;
9771    uint8_t ulCnt;
9772
9773    ulCnt = 1;
9774    ulInfo->list.count = ulCnt;
9775    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
9776    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
9777    if(ulInfo->list.array == NULLP)
9778    {
9779       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9780       return RFAILED;
9781    }
9782    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
9783    {
9784       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9785       if(ulInfo->list.array[arrIdx] == NULLP)
9786       {
9787          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9788          return RFAILED;
9789       }
9790    }
9791
9792    arrIdx = 0;
9793    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
9794    UPTransportLayerInformation_PR_gTPTunnel;
9795
9796    /*GTP TUNNEL*/
9797    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9798          sizeof(GTPTunnel_t));
9799    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
9800    {
9801       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9802       return RFAILED;
9803    }
9804    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9805       transportLayerAddress.size        = 4*sizeof(uint8_t);
9806    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9807          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9808          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9809    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9810          transportLayerAddress.buf == NULLP)
9811    {
9812       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9813       return RFAILED;
9814    }
9815
9816    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9817       transportLayerAddress.buf[0] = 192;
9818    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9819       transportLayerAddress.buf[1] = 168;
9820    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9821       transportLayerAddress.buf[2] = 130;
9822    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9823       transportLayerAddress.buf[3] = 82;
9824    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9825       transportLayerAddress.bits_unused = 0;
9826
9827    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
9828    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
9829    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
9830    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
9831
9832    /*GTP TEID*/
9833    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
9834       = 4 * sizeof(uint8_t);
9835    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9836          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9837          gTPTunnel->gTP_TEID.size);
9838    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9839          == NULLP)
9840    {
9841       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9842       return RFAILED;
9843    }
9844    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9845       gTP_TEID.buf[0] = 0;
9846    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9847       gTP_TEID.buf[1] = 0;
9848    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9849       gTP_TEID.buf[2] = 0;
9850    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
9851    {
9852      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
9853       * fetched based on the Drb Id */
9854
9855      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
9856       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
9857                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
9858    }
9859    else
9860    {
9861       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9862         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
9863    }
9864
9865    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
9866    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
9867    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
9868    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
9869    return ROK;
9870 }/*End of BuildULTnlInfo*/
9871
9872 /*******************************************************************
9873 *
9874 * @brief freeing the DRB item
9875 *
9876 * @details
9877 *
9878 *    Function : FreeDrbItem
9879 *
9880 *    Functionality: freeing the DRB item
9881 *
9882 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9883 *
9884 * @return ROK     - success
9885 *         RFAILED - failure
9886 *
9887 * ****************************************************************/
9888
9889 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
9890 {
9891    uint8_t arrIdx =0;
9892    SNSSAI_t *snssai =NULLP;
9893    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
9894
9895    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9896    switch(drbItem->qoSInformation.present)
9897    {
9898       case QoSInformation_PR_NOTHING:
9899          break;
9900       case QoSInformation_PR_eUTRANQoS:
9901          {
9902             if(drbItem->qoSInformation.choice.eUTRANQoS)
9903             {
9904                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9905             }
9906             break;
9907          }
9908       case QoSInformation_PR_choice_extension:
9909          {
9910             if(drbItem->qoSInformation.choice.choice_extension)
9911             {
9912                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
9913
9914                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
9915                if(snssai->sST.buf)
9916                {
9917                   CU_FREE(snssai->sST.buf,snssai->sST.size);
9918                }
9919                if(snssai->sD)
9920                {
9921                   if(snssai->sD->buf)
9922                   {
9923                      CU_FREE(snssai->sD->buf,snssai->sD->size);
9924                   }
9925                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
9926                }
9927
9928                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
9929                if(flowMap->list.array)
9930                {
9931                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
9932                   {
9933                      if(flowMap->list.array[arrIdx] )
9934                      {
9935                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
9936                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
9937                      }
9938                   }
9939                   CU_FREE(flowMap->list.array,flowMap->list.size);
9940                }
9941
9942                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9943             }
9944             break;
9945          }
9946
9947    }
9948    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
9949    if(drbItem->uLConfiguration)
9950    {
9951       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
9952    }
9953 }
9954
9955 /*******************************************************************
9956 *
9957 * @brief filling the DRB setup Mod item
9958 *
9959 * @details
9960 *
9961 *    Function : FillDrbItemToSetupMod
9962 *
9963 *    Functionality: filling the DRB setup Mod item
9964 *
9965 *
9966 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9967 *
9968 * @return ROK     - success
9969 *         RFAILED - failure
9970 *
9971 * ****************************************************************/
9972
9973 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
9974 {
9975    uint8_t ret = ROK;
9976
9977    /*Drb Id */
9978    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
9979    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
9980
9981    /*qoSInformation*/
9982    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9983
9984    switch(drbItem->qoSInformation.present)
9985    {
9986       case QoSInformation_PR_NOTHING:
9987       {
9988          break;
9989       }
9990       case QoSInformation_PR_eUTRANQoS:
9991       {
9992
9993          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9994          if(drbItem->qoSInformation.choice.eUTRANQoS)
9995          {
9996             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9997             return RFAILED;
9998          }
9999          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10000          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10001             PriorityLevel_no_priority;
10002
10003          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10004             Pre_emptionCapability_may_trigger_pre_emption;
10005
10006          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10007             Pre_emptionVulnerability_pre_emptable;
10008
10009          break;
10010       }
10011       case QoSInformation_PR_choice_extension:
10012       {
10013          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10014          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10015          {
10016             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10017             return RFAILED;
10018          }
10019
10020          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10021          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10022          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10023          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10024            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10025          if(ret != ROK)
10026          {
10027             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10028             return RFAILED;
10029          }
10030
10031          /*SNSSAI*/
10032          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10033                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10034          if(ret != ROK)
10035          {
10036             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10037             return RFAILED;
10038          }
10039
10040          /*Flows mapped to DRB List*/
10041          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10042                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10043           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10044          if(ret != ROK)
10045          {
10046             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10047             return RFAILED;
10048          }
10049       }
10050    }
10051
10052    /*ULUPTNLInformation To Be Setup List*/
10053    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10054       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10055    if(ret != ROK)
10056    {
10057       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10058       return RFAILED;
10059    }
10060
10061    /*RLCMode*/
10062    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10063    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10064
10065    ueCb->numDrb++;
10066    return ROK;
10067 }
10068
10069 /*******************************************************************
10070 *
10071 * @brief Builds the DRB to be Setup Mod ItemIes
10072 *
10073 * @details
10074 *
10075 *    Function : FillDrbItemList
10076 *
10077 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10078 *
10079 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10080 *
10081 * @return ROK     - success
10082 *         RFAILED - failure
10083 *
10084 * ****************************************************************/
10085
10086 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10087 {
10088    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10089    drbItemIe->criticality = Criticality_reject;
10090    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10091
10092    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10093    {
10094       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10095       return RFAILED;
10096    }
10097    return ROK;
10098 }
10099 /*******************************************************************
10100 *
10101 * @brief free the DRB to be Setup Mod list
10102 *
10103 * @details
10104 *
10105 *    Function : FreeDrbToBeSetupModList
10106 *
10107 *    Functionality: free the DRB to be Setup Mod list
10108 *
10109 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10110 *
10111 * @return ROK     - success
10112 *         RFAILED - failure
10113 *
10114 * ****************************************************************/
10115 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10116 {
10117    uint8_t arrIdx =0;
10118    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10119
10120    if(drbSet->list.array)
10121    {
10122       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10123       {
10124          if(drbSet->list.array[arrIdx] != NULLP)
10125          {
10126             if(arrIdx == 0)
10127             {
10128                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10129                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10130             }
10131             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10132          }
10133       }
10134       CU_FREE(drbSet->list.array, drbSet->list.size);
10135    }
10136
10137 }
10138
10139 /*******************************************************************
10140 *
10141 * @brief Builds the DRB to be Setup Mod list
10142 *
10143 * @details
10144 *
10145 *    Function : BuildDrbToBeSetupList
10146 *
10147 *    Functionality: Constructs the DRB to be Setup Mod list
10148 *
10149 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10150 *
10151 * @return ROK     - success
10152 *         RFAILED - failure
10153 *
10154 * ****************************************************************/
10155
10156 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10157 {
10158    uint8_t ret = ROK;
10159    uint8_t arrIdx =0;
10160    uint8_t drbCnt =0;
10161
10162    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10163    drbSet->list.count = drbCnt;
10164    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10165    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10166    if(drbSet->list.array == NULLP)
10167    {
10168       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10169       return  RFAILED;
10170    }
10171
10172    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10173    {
10174       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10175       if(drbSet->list.array[arrIdx] == NULLP)
10176       {
10177          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10178          return  RFAILED;
10179       }
10180
10181       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10182       if(ret != ROK)
10183       {
10184          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10185       }
10186    }
10187
10188    return ret;
10189 }
10190
10191 /*******************************************************************
10192 *
10193 * @brief Filling the DRB to be modified item
10194 *
10195 * @details
10196 *
10197 *    Function : FillDrbToBeModItem
10198 *
10199 *    Functionality: filling the DRB to be modified item
10200 *
10201 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10202 *
10203 * @return ROK     - success
10204 *         RFAILED - failure
10205 *
10206 * ****************************************************************/
10207
10208 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10209 {
10210    uint8_t ret = ROK;
10211    uint drbIdx=0;
10212    DrbInfo *drbToBeMod;
10213
10214    /*Drb Id */
10215    drbItem->dRBID = DRB2 + arrIdx;
10216
10217    /* Search for DRB ID in CU databse */
10218    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10219    {
10220       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10221       {
10222          drbToBeMod = &ueCb->drbList[drbIdx];
10223          break;
10224       }
10225    }
10226
10227    /*qoSInformation*/
10228    drbItem->qoSInformation = NULLP;
10229    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10230    if(drbItem->qoSInformation != NULLP)
10231    {
10232       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10233
10234       switch(drbItem->qoSInformation->present)
10235       {
10236          case QoSInformation_PR_NOTHING:
10237             {
10238                break;
10239             }
10240          case QoSInformation_PR_eUTRANQoS:
10241             {
10242
10243                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10244                if(drbItem->qoSInformation->choice.eUTRANQoS)
10245                {
10246                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10247                   return RFAILED;
10248                }
10249                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10250                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10251                   PriorityLevel_no_priority;
10252
10253                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10254                   Pre_emptionCapability_may_trigger_pre_emption;
10255
10256                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10257                   Pre_emptionVulnerability_pre_emptable;
10258
10259                break;
10260             }
10261          case QoSInformation_PR_choice_extension:
10262             {
10263                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10264                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10265                {
10266                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10267                   return RFAILED;
10268                }
10269
10270                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10271                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10272                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10273                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10274                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10275                if(ret != ROK)
10276                {
10277                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10278                   return RFAILED;
10279                }
10280
10281                /*SNSSAI*/
10282                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10283                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10284                if(ret != ROK)
10285                {
10286                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10287                   return RFAILED;
10288                }
10289
10290                /*Flows mapped to DRB List*/
10291                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10292                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10293                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10294                if(ret != ROK)
10295                {
10296                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10297                   return RFAILED;
10298                }
10299             }
10300       }
10301    }/* End of QoS */
10302
10303    /*ULUPTNLInformation To Be Setup List*/
10304    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10305             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10306    if(ret != ROK)
10307    {
10308       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10309       return RFAILED;
10310    }
10311    return ROK;
10312 }
10313
10314 /*******************************************************************
10315 *
10316 * @brief Builds the DRB to be modified Item IE
10317 *
10318 * @details
10319 *
10320 *    Function : FillDrbToBeModItemList
10321 *
10322 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10323 *
10324 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10325 *
10326 * @return ROK     - success
10327 *         RFAILED - failure
10328 *
10329 * ****************************************************************/
10330
10331 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10332 {
10333    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10334    drbItemIe->criticality = Criticality_reject;
10335    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10336    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10337    {
10338       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10339       return RFAILED;
10340    }
10341
10342    return ROK;
10343 }
10344
10345 /*******************************************************************
10346 *
10347 * @brief Builds the DRB to be modified list
10348 *
10349 * @details
10350 *
10351 *    Function : BuildDrbToBeModList
10352 *
10353 *    Functionality: Constructs the DRB to be modified list
10354 *
10355 * @params[in] DRBs_ToBeModified_List_t *drbSet
10356 *
10357 * @return ROK     - success
10358 *         RFAILED - failure
10359 *
10360 * ****************************************************************/
10361
10362 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10363 {
10364    uint8_t ret = ROK;
10365    uint8_t arrIdx =0;
10366    uint8_t drbCnt =0;
10367
10368    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10369    drbSet->list.count = drbCnt;
10370    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10371    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10372    if(drbSet->list.array == NULLP)
10373    {
10374       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10375       return  RFAILED;
10376    }
10377    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10378    {
10379       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10380       if(drbSet->list.array[arrIdx] == NULLP)
10381       {
10382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10383          return  RFAILED;
10384       }
10385
10386       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10387       if(ret != ROK)
10388       {
10389          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10390       }
10391    }
10392
10393    return ret;
10394 }
10395
10396 /*******************************************************************
10397 *
10398 * @brief freeing the DRB  item
10399 *
10400 * @details
10401 *
10402 *    Function : FreeModifiedDrbItem
10403 *
10404 *    Functionality: freeing the DRB 2 item
10405 *
10406 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10407 *
10408 * @return ROK     - success
10409 *         RFAILED - failure
10410 *
10411 * ****************************************************************/
10412
10413 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10414 {
10415    uint8_t arrIdx =0;
10416    SNSSAI_t *snssai =NULLP;
10417    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10418
10419    if(drbItem->qoSInformation != NULLP)
10420    {
10421       switch(drbItem->qoSInformation->present)
10422       {
10423          case QoSInformation_PR_NOTHING:
10424             break;
10425          case QoSInformation_PR_eUTRANQoS:
10426             {
10427                if(drbItem->qoSInformation->choice.eUTRANQoS)
10428                {
10429                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10430                }
10431                break;
10432             }
10433          case QoSInformation_PR_choice_extension:
10434             {
10435                if(drbItem->qoSInformation->choice.choice_extension)
10436                {
10437                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10438
10439                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10440                   if(snssai->sST.buf)
10441                   {
10442                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10443                   }
10444                   if(snssai->sD)
10445                   {
10446                      if(snssai->sD->buf)
10447                      {
10448                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10449                      }
10450                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10451                   }
10452
10453                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10454                   if(flowMap->list.array)
10455                   {
10456                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10457                      {
10458                         if(flowMap->list.array[arrIdx] )
10459                         {
10460                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10461                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10462                         }
10463                      }
10464                      CU_FREE(flowMap->list.array,flowMap->list.size);
10465                   }
10466
10467                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10468                }
10469                break;
10470             }
10471       }
10472    }
10473    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10474    if(drbItem->uLConfiguration)
10475    {
10476       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10477    }
10478 }
10479
10480 /*******************************************************************
10481 *
10482 * @brief free the DRB to be modfified list
10483 *
10484 * @details
10485 *
10486 *    Function : FreeDrbToBeModifiedList
10487 *
10488 *    Functionality: free the DRB to be Setup Mod list
10489 *
10490 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10491 *
10492 * @return ROK     - success
10493 *         RFAILED - failure
10494 *
10495 * ****************************************************************/
10496 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10497 {
10498    uint8_t arrIdx =0;
10499    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10500
10501    if(drbSet->list.array)
10502    {
10503       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10504       {
10505          if(drbSet->list.array[arrIdx] != NULLP)
10506          {
10507             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10508             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10509             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10510          }
10511       }
10512       CU_FREE(drbSet->list.array, drbSet->list.size);
10513    }
10514
10515 }
10516
10517 /*******************************************************************
10518  *
10519  * @brief  free the UeContextModification Request
10520  *
10521  * @details
10522  *
10523  *    Function : FreeUeContextModicationRequest
10524  *
10525  *    Functionality : deallocation of memory allocated in UeContextModiification
10526  request
10527  *
10528  * @params[in] F1AP_PDU_t *f1apMsg
10529  *
10530  * @return void
10531 *
10532 * ****************************************************************/
10533 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10534 {
10535    uint8_t arrIdx =0 , ieId=0;
10536    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10537
10538    if(f1apMsg)
10539    {
10540       if(f1apMsg->choice.initiatingMessage)
10541       {
10542          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10543          if(ueContextModifyReq->protocolIEs.list.array)
10544          {
10545             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10546             {
10547                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10548                {
10549                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10550                   switch(ieId)
10551                   {
10552                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10553                         break;
10554                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10555                         break;
10556                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10557                         {
10558                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10559                                  choice.DRBs_ToBeSetupMod_List);
10560                            break;
10561                         }
10562                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10563                         {
10564                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10565                                  choice.DRBs_ToBeModified_List);
10566                            break;
10567                         }
10568                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10569                         break;
10570                     case ProtocolIE_ID_id_RRCContainer:
10571                     {
10572                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10573                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10574                     }
10575
10576                   }
10577                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10578                }
10579             }
10580             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10581          }
10582          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10583       }
10584       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10585    }
10586 }
10587
10588 /*******************************************************************
10589  *
10590  * @brief Builds the Ue Context Modification Req
10591  *
10592  * @details
10593  *
10594  *    Function : BuildAndSendUeContextModificationReq
10595  *
10596  *    Functionality: Constructs the Ue Context Modification Req
10597  *
10598  * @params[in]
10599  *
10600  * @return ROK     - success
10601  *         RFAILED - failure
10602  *
10603  * ****************************************************************/
10604 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10605 {
10606    uint8_t    ieIdx = 0;
10607    uint8_t    elementCnt = 0;
10608    uint8_t    ret = RFAILED;
10609    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10610    F1AP_PDU_t *f1apMsg = NULLP;
10611    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10612    asn_enc_rval_t         encRetVal;
10613    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10614    while(1)
10615    {
10616       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10617       if(f1apMsg == NULLP)
10618       {
10619          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10620          break;
10621       }
10622
10623       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10624
10625       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10626       if(f1apMsg->choice.initiatingMessage == NULLP)
10627       {
10628          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10629          break;
10630       }
10631       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10632       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10633       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10634
10635       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10636
10637       if(action == MODIFY_UE)
10638          elementCnt = 4;
10639       else if(action == QUERY_CONFIG)
10640          elementCnt = 3;
10641       else if(action == RRC_RECONFIG_COMPLETE_IND)
10642          elementCnt = 3;
10643       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10644          elementCnt = 5;
10645
10646       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10647       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10648
10649       /* Initialize the UE context modification members */
10650       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10651       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10652       {
10653          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10654          break;
10655       }
10656
10657       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10658       {
10659          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10660          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10661          {
10662             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10663             break;
10664          }
10665       }
10666
10667       ieIdx=0;
10668       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10669       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10670       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10671                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10672       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10673
10674       ieIdx++;
10675       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10676       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10677       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10678                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10679       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10680
10681       if(action == MODIFY_UE)
10682       {
10683          /* DRB to be setup list */
10684          ieIdx++;
10685          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10686          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10687          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10688                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10689          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10690                   value.choice.DRBs_ToBeSetupMod_List));
10691
10692          /* DRB to be modified list */
10693          ieIdx++;
10694          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10695          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10696          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10697                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10698          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10699                   value.choice.DRBs_ToBeModified_List));
10700
10701          /* TODO: DRB to be release list */
10702
10703          if(ret != ROK)
10704          {
10705             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
10706             break;
10707          }
10708
10709          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
10710       }
10711       else if(action == QUERY_CONFIG)
10712       {
10713          ieIdx++;
10714          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10715          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10716          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10717             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10718          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10719       }
10720       else if(action == RRC_RECONFIG_COMPLETE_IND)
10721       {
10722          ieIdx++;
10723          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10724          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10725          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10726             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
10727          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
10728             RRCReconfigurationCompleteIndicator_true;
10729       }
10730       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10731       {
10732          ieIdx++;
10733          if(action == STOP_DATA_TX)
10734          {
10735             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10736             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10737             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10738             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10739             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10740             TransmissionActionIndicator_stop;
10741          }
10742          else if (action == RESTART_DATA_TX)
10743          {
10744             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10745             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10746             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10747             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10748             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10749             TransmissionActionIndicator_restart;
10750          }
10751
10752          ieIdx++;
10753          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10754          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10755          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10756          UEContextModificationRequestIEs__value_PR_RRCContainer;
10757          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
10758          {
10759             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
10760             return RFAILED;
10761          }
10762
10763          /* RRC delivery status request */
10764          ieIdx++;
10765          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
10766          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10767          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
10768          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
10769       }
10770
10771       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10772
10773       /* Encode the F1SetupRequest type as APER */
10774       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10775       encBufSize = 0;
10776       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10777
10778       /* Encode results */
10779       if(encRetVal.encoded == ENCODE_FAIL)
10780       {
10781          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
10782                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10783          break;
10784       }
10785       else
10786       {
10787          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
10788 #if 0
10789          /* This for loop was going into an infinite loop even though encBufSize
10790           * has a small value. Hence commented this
10791           */
10792          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10793          {
10794             DU_LOG("%x",encBuf[ieIdx]);
10795          }
10796 #endif
10797       }
10798
10799       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10800       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10801       {
10802          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
10803          break;
10804       }
10805
10806       ret = ROK;
10807       break;
10808
10809    }
10810    FreeUeContextModicationRequest(f1apMsg);
10811    return ret;
10812 }
10813
10814 /*****************************************************************i
10815  *
10816 * @brief Free memory allocated for UE Context Release Command
10817 *
10818 * @details
10819 *
10820 *    Function : FreeUeContextReleaseCommand
10821 *
10822 *    Functionality:
10823 *         - Free memory allocated for UE Context Release Command
10824 *
10825 * @params[in] F1AP_PDU_t *f1apMsg
10826 * @return void
10827 *
10828 * *************************************************************/
10829 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
10830 {
10831    uint8_t ieIdx;
10832    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
10833
10834    if(f1apMsg)
10835    {
10836       if(f1apMsg->choice.initiatingMessage)
10837       {
10838          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10839          if(ueReleaseCommand->protocolIEs.list.array)
10840          {
10841             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
10842             {
10843                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10844             }
10845             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
10846          }
10847          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10848       }
10849       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10850    }
10851 }
10852 /*******************************************************************
10853  *
10854  * @brief Builds the Ue Context Release Command
10855  *
10856  * @details
10857 *
10858 *    Function : BuildAndSendUeContextReleaseCommand
10859 *
10860 *    Functionality: Constructs the Ue Context Release Command
10861 *
10862 * @params[in]
10863 *
10864 * @return ROK     - success
10865 *         RFAILED - failure
10866 *
10867 * ****************************************************************/
10868 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
10869 {
10870    bool       memAllocFailed = false;
10871    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
10872    DuDb *duDb;
10873    CuUeCb *ueCb;
10874    F1AP_PDU_t *f1apMsg = NULLP;
10875    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
10876
10877    asn_enc_rval_t         encRetVal;
10878    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
10879
10880    while(true)
10881    {
10882       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10883       if(f1apMsg == NULLP)
10884       {
10885          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
10886          break;
10887       }
10888
10889       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10890
10891       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10892       if(f1apMsg->choice.initiatingMessage == NULLP)
10893       {
10894          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
10895          break;
10896       }
10897       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
10898       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10899       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
10900
10901       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10902
10903       SEARCH_DU_DB(duIdx, duId, duDb);
10904       ueCb = &duDb->ueCb[duUeF1apId-1];
10905       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
10906          elementCnt = 3;
10907       else
10908          elementCnt = 4;
10909
10910       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
10911       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
10912
10913       /* Initialize the UE context modification members */
10914       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
10915       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
10916       {
10917          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
10918          break;
10919       }
10920
10921       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10922       {
10923          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10924          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
10925          {
10926             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
10927             memAllocFailed = true;
10928             break;
10929          }
10930       }
10931
10932       if(memAllocFailed == true)
10933       {
10934          break;
10935       }
10936
10937       ieIdx=0;
10938       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10939       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10940       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10941       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
10942       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
10943
10944       ieIdx++;
10945       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10946       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10947       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10948       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
10949       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
10950
10951       /* Cause of UE context release */
10952       ieIdx++;
10953       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
10954       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10955       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10956                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
10957       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10958       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
10959                                                                                                      CauseRadioNetwork_normal_release;
10960       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
10961       {
10962          /* RRC Container for RRC release */
10963          ieIdx++;
10964          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10965          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10966          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10967                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
10968          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
10969          bufLen =7;
10970          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
10971          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
10972                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
10973          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
10974          {
10975             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
10976             break;
10977          }
10978          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
10979          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
10980       }
10981       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10982
10983       /* Encode the UE Context Release Command type as APER */
10984       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10985       encBufSize = 0;
10986       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10987             encBuf);
10988
10989       /* Encode results */
10990       if(encRetVal.encoded == ENCODE_FAIL)
10991       {
10992          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
10993                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10994          break;
10995       }
10996       else
10997       {
10998          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
10999          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11000          {
11001             DU_LOG("%x",encBuf[ieIdx]);
11002          }
11003       }
11004
11005       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11006       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11007       {
11008          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11009          break;
11010       }
11011
11012       ret = ROK;
11013       break;
11014
11015    }
11016    FreeUeContextReleaseCommand(f1apMsg);
11017    return ret;
11018 }
11019 /*******************************************************************
11020 *
11021 * @brief process Ue context release request
11022 *
11023 * @details
11024 *
11025 *    Function : procUeContextReleaseReq
11026 *
11027 *    Functionality:
11028 *         - process Ue context release request
11029 *
11030 * @params[in] F1AP_PDU_t *f1apMsg
11031 * @return ROK     - success
11032 *         RFAILED - failure
11033 *
11034 * ****************************************************************/
11035 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11036 {
11037    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11038
11039    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11040    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11041
11042    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11043    {
11044       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11045       {
11046          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11047             {
11048                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11049                break;
11050             }
11051          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11052             {
11053                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11054                break;
11055             }
11056          default:
11057               break;
11058       }
11059    }
11060
11061    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11062    {
11063       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11064       return RFAILED;
11065    }
11066    return ROK;
11067 }
11068 /*******************************************************************
11069 *
11070 * @brief processing of Gnb-DU config update
11071 *
11072 * @details
11073 *
11074 *    Function : procGnbDuUpdate
11075 *
11076 *    Functionality:
11077 *         - processing of Gnb-DU config update
11078 *
11079 * @params[in] F1AP_PDU_t *f1apMsg
11080 * @return ROK     - success
11081 *         RFAILED - failure
11082 *
11083 * ****************************************************************/
11084 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11085 {
11086    bool cellToBeDelete = false;
11087    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11088    uint16_t nrCellId;
11089    DuDb *duDb;
11090    CuCellCb *cellCb;
11091    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11092
11093    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11094    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11095    {
11096       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11097       {
11098          case ProtocolIE_ID_id_TransactionID:
11099             break;
11100          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11101             break;
11102          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11103             {
11104                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11105                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11106                   Served_Cells_To_Delete_List.list.array[0];
11107                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11108                cellToBeDelete = true;
11109                break;
11110             }
11111          case ProtocolIE_ID_id_gNB_DU_ID:
11112             break;
11113       }
11114    }
11115    if(BuildAndSendDUUpdateAck(duId) != ROK)
11116    {
11117       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11118       return RFAILED;
11119    }
11120 #if 0
11121    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11122     * commented this trigger for now */
11123
11124    if(cellToBeDelete == false)
11125    {
11126       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11127       if(BuildAndSendF1ResetReq() != ROK)
11128       {
11129          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11130          return RFAILED;
11131       }
11132    }
11133 #endif
11134    if(cellToBeDelete == true)
11135    {
11136       SEARCH_DU_DB(duIdx, duId, duDb);
11137       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11138       if(cellCb->numUe == 0)
11139       {
11140          memset(cellCb, 0, sizeof(CuCellCb));
11141          duDb->numCells--;
11142       }
11143       else
11144          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11145    }
11146    return ROK;
11147 }
11148
11149 /*******************************************************************
11150 *
11151 * @brief storing slice list in CU database
11152 *
11153 * @details
11154 *
11155 *    Function : buildSliceList
11156 *
11157 *    Functionality:
11158 *         - storing slice list in CU database
11159 *
11160 * @params[in] SliceSupportList_t *sliceSupportList
11161 * @return ROK     - success
11162 *         RFAILED - failure
11163 *
11164 * ****************************************************************/
11165 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11166 {
11167    uint8_t sliceListIdx = 0;
11168
11169    if(sliceSupportList)
11170    {
11171       if(sliceSupportList->list.array)
11172       {
11173          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11174          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11175          {
11176             if(sliceSupportList->list.array[sliceListIdx])
11177             {
11178                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11179                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11180                {
11181                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11182                    return RFAILED;
11183                }
11184                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11185                {
11186                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11187                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11188                }
11189                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11190                {
11191                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11192                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11193                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11194                }
11195             }
11196          }
11197       }
11198    }
11199    return ROK;
11200 }
11201
11202 /****************************************************************
11203  * @brief Function to process Srb Setup Mod List
11204  *
11205  * @details
11206  *
11207  *    Function : procSrbSetupModList
11208  *
11209  *    Functionality:
11210  *         - Function to process SRB Setup Mod List
11211  *
11212  * @params[in]
11213  * @return ROK     - success
11214  *         RFAILED - failure
11215  *
11216  * ****************************************************************/
11217 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11218 {
11219    uint8_t arrIdx = 0, srbIdx;
11220    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11221
11222    if(srbSetupList != NULLP)
11223    {
11224       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11225       {
11226          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11227          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11228          {
11229             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11230             {
11231                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11232                {
11233                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11234                   break;
11235                }
11236             }
11237          }
11238
11239       }
11240    }
11241    return ROK;
11242 }
11243
11244
11245 /****************************************************************
11246  * @brief Function to process Drb Setup Mod List
11247  *
11248  * @details
11249  *
11250  *    Function : procDrbSetupModList
11251  *
11252  *    Functionality:
11253  *         - Function to process DRB Setup Mod List
11254  *
11255  * @params[in]
11256  * @return ROK     - success
11257  *         RFAILED - failure
11258  *
11259  * ****************************************************************/
11260 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11261 {
11262    uint8_t arrIdx = 0, drbIdx;
11263    uint32_t teId = 0;
11264    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11265
11266    if(drbSetupList != NULLP)
11267    {
11268       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11269       {
11270          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11271          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11272          {
11273             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11274             {
11275                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11276                {
11277                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11278                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11279                   break;
11280                }
11281             }
11282
11283             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11284             {
11285             /* extracting teId */
11286             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11287             if(teId > 0)
11288             {
11289               if(addDrbTunnels(duId, teId)== ROK)
11290               {
11291                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11292               }
11293             }
11294             else
11295                return RFAILED;
11296             }
11297          }
11298       }
11299    }
11300    return ROK;
11301 }
11302
11303 /*******************************************************************
11304 *
11305 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11306 *
11307 * @details
11308 *
11309 *    Function : procServedCellPlmnList
11310 *
11311 *    Functionality:
11312 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11313 *         SNSSAI list
11314 *
11315 * @params[in] F1AP_PDU_t *f1apMsg
11316 * @return ROK     - success
11317 *         RFAILED - failure
11318 *
11319 * ****************************************************************/
11320 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11321 {
11322    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11323    ProtocolExtensionContainer_4624P3_t **ieExtend;
11324
11325    if(srvPlmn->list.array)
11326    {
11327       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11328       {
11329          if(srvPlmn->list.array[srvPlmnIdx])
11330          {
11331             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11332             if(*ieExtend)
11333             {
11334                if((*ieExtend)->list.array)
11335                {
11336                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11337                   {
11338                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11339                      {
11340                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11341                         {
11342                            case ProtocolIE_ID_id_TAISliceSupportList:
11343                               {
11344                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11345                                           extensionValue.choice.SliceSupportList) != ROK)
11346                                  {
11347                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11348                                     return RFAILED;
11349                                  }
11350                               }
11351                         }
11352                      }
11353                   }
11354                }
11355             }
11356          }
11357       }
11358    }
11359    return ROK;
11360 }
11361
11362 /****************************************************************
11363  * @brief Function to process Ue Context Modification Response
11364  *
11365  * @details
11366  *
11367  *    Function : procUeContextModificationResponse
11368  *
11369  *    Functionality:
11370  *         - Function to process Ue Context Modification Response
11371  *
11372  * @params[in]
11373  * @return ROK     - success
11374  *         RFAILED - failure
11375  *
11376  * ****************************************************************/
11377 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11378 {
11379    uint8_t idx=0, duIdx=0;
11380    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11381    DuDb *duDb = NULLP;
11382    CuUeCb *ueCb = NULLP;
11383    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11384
11385    SEARCH_DU_DB(duIdx, duId, duDb);
11386    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11387
11388    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11389    {
11390       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11391       {
11392           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11393              {
11394                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11395                 break;
11396              }
11397           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11398              {
11399                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11400                 ueCb = &duDb->ueCb[duUeF1apId-1];
11401                 break;
11402              }
11403           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11404              {
11405                 /* Adding Tunnels for successful DRB */
11406                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11407                 break;
11408
11409              }
11410           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11411              {
11412                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11413                 break;
11414              }
11415          case ProtocolIE_ID_id_DUtoCURRCInformation:
11416              {
11417                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11418                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11419                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11420                 {
11421                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11422                    return RFAILED;
11423                 }
11424                 break;
11425              }
11426
11427       }
11428    }
11429
11430    /* If UE is in handover and UE context is not yet created at target DU, then send
11431     * UE context setup request to target DU */
11432    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11433    {
11434       uint8_t ueIdx = 0;
11435       DuDb *tgtDuDb = NULLP;
11436       CuUeCb *ueCbInTgtDu = NULLP;
11437
11438       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11439       if(tgtDuDb)
11440       {
11441          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11442           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11443           * DB */
11444          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11445          {
11446             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11447             {
11448                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11449                break;
11450             }
11451          }
11452
11453          /* If UE context is not found in Target DU DU, send UE context setup
11454           * request */
11455          if(ueCbInTgtDu == NULLP)
11456          {
11457             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
11458             {
11459                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11460                return RFAILED;
11461             }
11462          }
11463       }
11464    }
11465
11466    return ROK;
11467 }
11468
11469 /*******************************************************************
11470 *
11471 * @brief processing of F1 setup request
11472 *
11473 * @details
11474 *
11475 *    Function : procF1SetupReq
11476 *
11477 *    Functionality:
11478 *         - processing of  F1 setup request
11479 *
11480 * @params[in] F1AP_PDU_t *f1apMsg
11481 * @return ROK     - success
11482 *         RFAILED - failure
11483 *
11484 * ****************************************************************/
11485 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11486 {
11487    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11488    uint32_t duId = 0;
11489    uint64_t nrCellId = 0;
11490    DuDb     *duDb = NULLP;
11491    CuCellCb *cellCb = NULLP;
11492    BIT_STRING_t nrcellIdentity;
11493    F1SetupRequest_t *f1SetupReq = NULLP;
11494    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11495    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11496
11497    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11498    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11499    {
11500       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11501       {
11502          case ProtocolIE_ID_id_gNB_DU_ID:
11503            {
11504               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11505               SEARCH_DU_DB(duIdx, duId, duDb);
11506               if(duDb == NULLP)
11507               {
11508                  duDb = &cuCb.duInfo[cuCb.numDu];
11509                  memset(duDb, 0, sizeof(DuDb));
11510                  duDb->duId = duId;
11511                  cuCb.numDu++;
11512                  *destDuId = duId;
11513               }
11514               else
11515                  return;
11516               break;
11517            }
11518          case ProtocolIE_ID_id_gNB_DU_Name:
11519            {
11520               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11521               break;
11522            }
11523          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11524            {
11525                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11526                if(duServedCell->list.array)
11527                {
11528                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11529                   {
11530                      if(duServedCell->list.array[plmnidx])
11531                      {
11532                         switch(duServedCell->list.array[plmnidx]->id)
11533                         {
11534                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11535                            {
11536                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11537                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11538                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11539
11540                               bitStringToInt(&nrcellIdentity, &nrCellId);
11541                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11542                               if(cellCb == NULLP)
11543                               {
11544                                  cellCb = &duDb->cellCb[duDb->numCells];
11545                                  memset(cellCb, 0, sizeof(CuCellCb));
11546                                  cellCb->nrCellId = nrCellId;
11547                                  cellCb->cellStatus = CELL_ACTIVE;
11548                                  duDb->numCells++;
11549                               }
11550                            }
11551                         }
11552                      }
11553                   }
11554                }
11555            }
11556       }
11557    }
11558    if(ret == ROK)
11559    {
11560       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11561    }
11562    else
11563    {
11564        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11565    }
11566 }
11567
11568 /****************************************************************
11569 *
11570 * @brief processing of UE Context Release Complete
11571 *
11572 * @details
11573 *
11574 *    Function : procUeContextReleaseComplete
11575 *
11576 *    Functionality:
11577 *         - processing of UE Context Release Complete
11578 *
11579 * @params[in] F1AP_PDU_t *f1apMsg
11580 * @return ROK     - success
11581 *         RFAILED - failure
11582 *
11583 * ****************************************************************/
11584 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11585 {
11586    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0;
11587    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11588    DuDb *duDb = NULLP;
11589    CuUeCb *ueCb = NULLP;
11590    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11591
11592    SEARCH_DU_DB(duIdx, duId, duDb);
11593    if(!duDb)
11594    {
11595       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11596       return;
11597    }
11598
11599    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11600    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11601    {
11602       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11603       {
11604          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11605             {
11606                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11607                break;
11608             }
11609          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11610             {
11611                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11612                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11613                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11614                {
11615                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11616                   {
11617                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11618                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11619                      {
11620                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11621                         ueCb->cellCb->numUe--;
11622                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
11623                         {
11624                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11625                            duDb->numCells--;
11626                         }
11627                         break;
11628                      }
11629                   }
11630                }
11631                memset(ueCb, 0, sizeof(CuUeCb));
11632                duDb->numUe--;
11633                break;
11634             }
11635       }
11636    }
11637 }
11638
11639 /*******************************************************************
11640  *
11641  * @brief Builds the Paging cell list
11642  *
11643  * @details
11644  *
11645  *    Function : BuildPagingCellList
11646  *
11647  *    Functionality: Build the paging cell list
11648  *
11649  * @params[in] PagingCell_list_t  *pagingCelllist,
11650  *
11651  * @return ROK     - success
11652  *         RFAILED - failure
11653  *
11654  * ****************************************************************/
11655 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11656 {
11657    uint8_t cellIdx =0;
11658    PagingCell_ItemIEs_t *pagingCellItemIes;
11659    PagingCell_Item_t *pagingCellItem;
11660
11661    pagingCelllist->list.count = numCells;
11662    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11663    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11664    if(pagingCelllist->list.array == NULLP)
11665    {
11666       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11667       return RFAILED;
11668    }
11669
11670    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11671    {
11672       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11673       if(pagingCelllist->list.array[cellIdx] == NULLP)
11674       {
11675          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11676          return RFAILED;
11677       }
11678    }
11679
11680    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11681    {
11682       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11683       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
11684       pagingCellItemIes->criticality = Criticality_ignore;
11685       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
11686       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11687
11688       /* Fill NrCgi Information */
11689       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
11690    }
11691
11692    return ROK;
11693 }
11694
11695 /*******************************************************************
11696  *
11697  * @brief Deallocation of memory allocated in paging msg
11698  *
11699  * @details
11700  *
11701  *    Function :FreePagingMsg
11702  *
11703  *    Functionality: Deallocation of memory allocated in paging msg
11704  *
11705  * @params[in] F1AP_PDU_t *f1apMsg
11706  *
11707  * @return void
11708  *
11709  * ****************************************************************/
11710 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
11711 {
11712    uint8_t ieIdx, cellIdx;
11713    Paging_t   *paging;
11714    PagingCell_ItemIEs_t *pagingCellItemIes;
11715    PagingCell_Item_t *pagingCellItem;
11716    PagingCell_list_t  *pagingCelllist;
11717
11718    if(f1apMsg)
11719    {
11720       if(f1apMsg->choice.initiatingMessage)
11721       {
11722          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11723          if(paging->protocolIEs.list.array)
11724          {
11725             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
11726             {
11727                if(paging->protocolIEs.list.array[ieIdx])
11728                {
11729                   switch(paging->protocolIEs.list.array[ieIdx]->id)
11730                   {
11731                      case ProtocolIE_ID_id_UEIdentityIndexValue:
11732                      {
11733                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11734                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11735                         break;
11736                      }
11737
11738                      case ProtocolIE_ID_id_PagingIdentity:
11739                      {
11740                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
11741                         {
11742                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11743                            {
11744                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
11745                               {
11746                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11747                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11748                               }
11749                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
11750                                 sizeof(struct CNUEPagingIdentity));
11751                            }
11752                         }
11753                         break;
11754                      }
11755
11756                      case ProtocolIE_ID_id_PagingCell_List:
11757                      {
11758                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
11759                         if(pagingCelllist->list.array)
11760                         {
11761                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11762                            {
11763                               if(pagingCelllist->list.array[cellIdx])
11764                               {
11765                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11766                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
11767                                   {
11768                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11769                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
11770                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
11771                                   }
11772                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11773                               }
11774                            }
11775                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
11776                         }
11777                         break;
11778                      }
11779                   }
11780                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11781                }
11782             }
11783             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11784          }
11785          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11786       }
11787       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11788    }
11789 }
11790 /*******************************************************************
11791  *
11792  * @brief Builds and sends the paging message if UE is in idle mode
11793  *
11794  * @details
11795  *
11796  *    Function : BuildAndSendPagingMsg
11797  *
11798  *    Functionality: Builds and sends the paging message
11799  *
11800  * @params[in] uint32_t duId, uint8_t gsTmsi
11801  *
11802  * @return ROK     - success
11803  *         RFAILED - failure
11804  *
11805  * ****************************************************************/
11806 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
11807 {
11808    bool       memAllocFailed = false;
11809    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
11810    uint16_t   ueId = 0, duIdx = 0;
11811
11812    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
11813     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
11814    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
11815    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
11816
11817    F1AP_PDU_t *f1apMsg = NULLP;
11818    Paging_t   *paging = NULLP;
11819    DuDb       *duDb;
11820    asn_enc_rval_t         encRetVal;
11821
11822    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
11823
11824    SEARCH_DU_DB(duIdx, duId, duDb);
11825    if(duDb == NULLP)
11826    {
11827       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
11828       return ret;
11829    }
11830
11831    while(true)
11832    {
11833       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11834       if(f1apMsg == NULLP)
11835       {
11836          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
11837          break;
11838       }
11839
11840       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11841
11842       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11843       if(f1apMsg->choice.initiatingMessage == NULLP)
11844       {
11845          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
11846          break;
11847       }
11848       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
11849       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11850       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
11851
11852       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11853
11854       elementCnt = 5;
11855       paging->protocolIEs.list.count = elementCnt;
11856       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
11857
11858       /* Initialize the Paging Message members */
11859       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11860       if(paging->protocolIEs.list.array == NULLP)
11861       {
11862          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
11863          break;
11864       }
11865
11866       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11867       {
11868          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11869          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
11870          {
11871             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11872             memAllocFailed = true;
11873             break;
11874          }
11875       }
11876
11877       if(memAllocFailed == true)
11878       {
11879          break;
11880       }
11881
11882       /* UE Identity Index Value */
11883       ieIdx=0;
11884       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
11885       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11886       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
11887       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
11888       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
11889       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11890             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11891       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
11892       {
11893          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11894          break;
11895       }
11896
11897       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
11898       ueId = gsTmsi % 1024;
11899       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
11900
11901       /* Paging Identity */
11902       ieIdx++;
11903       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
11904       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11905       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
11906       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
11907                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
11908       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
11909             sizeof(struct CNUEPagingIdentity));
11910       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11911       {
11912          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11913          break;
11914       }
11915
11916       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
11917                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
11918
11919       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
11920       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11921             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11922       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
11923       {
11924          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11925          break;
11926       }
11927
11928       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
11929             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
11930
11931       /* Paging Drx */
11932       ieIdx++;
11933       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
11934       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11935       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
11936       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
11937
11938       /* Paging Priority */
11939       ieIdx++;
11940       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
11941       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11942       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
11943       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
11944
11945       /* Paging Cell List */
11946       ieIdx++;
11947       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
11948       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11949       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
11950       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
11951       {
11952          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
11953          break;
11954       }
11955
11956       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11957
11958       /* Encode the UE Context Release Command type as APER */
11959       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11960       encBufSize = 0;
11961       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11962             encBuf);
11963
11964       /* Encode results */
11965       if(encRetVal.encoded == ENCODE_FAIL)
11966       {
11967          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11968                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11969          break;
11970       }
11971       else
11972       {
11973          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
11974          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11975          {
11976             DU_LOG("%x",encBuf[ieIdx]);
11977          }
11978       }
11979
11980       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11981       {
11982          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11983          break;
11984       }
11985
11986       ret = ROK;
11987       break;
11988
11989    }
11990
11991    FreePagingMsg(f1apMsg);
11992    return ret;
11993 }
11994
11995 /*******************************************************************
11996  *
11997  * @brief Handles received F1AP message and sends back response
11998  *
11999  * @details
12000  *
12001  *    Function : F1APMsgHdlr
12002  *
12003  *    Functionality:
12004  *         - Decodes received F1AP control message
12005  *         - Prepares response message, encodes and sends to SCTP
12006  *
12007  * @params[in]
12008  * @return ROK     - success
12009  *         RFAILED - failure
12010  *
12011  * ****************************************************************/
12012 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12013 {
12014    int i;
12015    char *recvBuf;
12016    MsgLen copyCnt;
12017    MsgLen recvBufLen;
12018    F1AP_PDU_t *f1apMsg = NULLP;
12019    asn_dec_rval_t rval; /* Decoder return value */
12020    F1AP_PDU_t f1apasnmsg ;
12021
12022    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12023    ODU_PRINT_MSG(mBuf, 0,0);
12024
12025    /* Copy mBuf into char array to decode it */
12026    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12027    CU_ALLOC(recvBuf, (Size)recvBufLen);
12028
12029    if(recvBuf == NULLP)
12030    {
12031       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12032       return;
12033    }
12034    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12035    {
12036       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12037       return;
12038    }
12039
12040    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12041    for(i=0; i< recvBufLen; i++)
12042    {
12043       DU_LOG("%x",recvBuf[i]);
12044    }
12045
12046    /* Decoding flat buffer into F1AP messsage */
12047    f1apMsg = &f1apasnmsg;
12048    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12049
12050    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12051    CU_FREE(recvBuf, (Size)recvBufLen);
12052
12053    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12054    {
12055       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12056       return;
12057    }
12058    DU_LOG("\n");
12059    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12060
12061    switch(f1apMsg->present)
12062    {
12063       case F1AP_PDU_PR_initiatingMessage:
12064          {
12065             switch(f1apMsg->choice.initiatingMessage->value.present)
12066             {
12067                case InitiatingMessage__value_PR_Reset:
12068                   {
12069                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12070                      BuildAndSendF1ResetAck();
12071                      break;
12072                   }
12073
12074                case InitiatingMessage__value_PR_F1SetupRequest:
12075                   {
12076                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12077                      procF1SetupReq(duId, f1apMsg);
12078                      break;
12079                   }
12080
12081                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12082                   {
12083                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12084                      procGnbDuUpdate(*duId, f1apMsg);
12085                      break;
12086                   }
12087                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12088                   {
12089                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12090                      procInitULRRCMsg(*duId, f1apMsg);
12091                      break;
12092                   }
12093                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12094                   {
12095                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12096                      procUlRrcMsg(*duId, f1apMsg);
12097                      break;
12098                   }
12099
12100                case InitiatingMessage__value_PR_RRCDeliveryReport:
12101                   {
12102                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12103                      break;
12104                   }
12105                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12106                   {
12107                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12108                      procUeContextReleaseReq(*duId, f1apMsg);
12109                      break;
12110                   }
12111                default:
12112                   {
12113                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12114                            f1apMsg->choice.initiatingMessage->value.present);
12115                      return;
12116                   }
12117             }/* End of switch(initiatingMessage) */
12118             break;
12119          }
12120
12121       case F1AP_PDU_PR_successfulOutcome:
12122          {
12123             switch(f1apMsg->choice.successfulOutcome->value.present)
12124             {
12125                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12126                   {
12127                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12128                      break;
12129                   }
12130                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12131                   {
12132                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12133                      procUeContextSetupResponse(*duId, f1apMsg);
12134                      break;
12135                   }
12136                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12137                   {
12138                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12139                      procUeContextModificationResponse(*duId, f1apMsg);
12140                      break;
12141                   }
12142                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12143                   {
12144                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12145                       procUeContextReleaseComplete(*duId, f1apMsg);
12146                       break;
12147                   }
12148                default:
12149                   {
12150                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12151                            f1apMsg->choice.successfulOutcome->value.present);
12152                      return;
12153                   }
12154             }/* End of switch(successfulOutcome) */
12155             break;
12156          }
12157       default:
12158          {
12159             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12160             return;
12161          }
12162    }/* End of switch(f1apMsg->present) */
12163
12164 } /* End of F1APMsgHdlr */
12165
12166 /**********************************************************************
12167   End of file
12168  **********************************************************************/