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 #include "DRX-ConfigRrc.h"
 134
 135 #include "cu_stub_sctp.h"
 136 #include "cu_stub_egtp.h"
 137 #include "cu_f1ap_msg_hdl.h"
 138 #include "cu_stub.h"
 139
 140 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 141 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 142
 143 /*******************************************************************
 144  *
 145  * @brief Sends F1 msg over SCTP
 146  *
 147  * @details
 148  *
 149  *    Function : SendF1APMsg
 150  *
 151  *    Functionality: Sends F1 msg over SCTP
 152  *
 153  * @params[in] Region region
 154  *             Pool pool
 155  * @return ROK     - success
 156  *         RFAILED - failure
 157  *
 158  * ****************************************************************/
 159 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 160 {
 161    Buffer *mBuf = NULLP;
 162
 163    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 164    {
 165       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 166       {
 167          ODU_PRINT_MSG(mBuf, 0,0);
 168
 169          if(sctpSend(duId, mBuf) != ROK)
 170          {
 171             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 172             ODU_PUT_MSG_BUF(mBuf);
 173             return RFAILED;
 174          }
 175       }
 176       else
 177       {
 178          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 179          ODU_PUT_MSG_BUF(mBuf);
 180          return RFAILED;
 181       }
 182       ODU_PUT_MSG_BUF(mBuf);
 183    }
 184    else
 185    {
 186       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 187       return RFAILED;
 188    }
 189
 190    return ROK;
 191 } /* SendF1APMsg */
 192
 193 /********************************************************************
 194  *
 195  * @brief Builds and sends the F1SetupResponse
 196  *
 197  * @details
 198  *
 199  *    Function : BuildAndSendF1SetupRsp
 200  *
 201  *    Functionality: Constructs the F1SetupResponse message and sends
 202  *                   it back to the DU through SCTP.
 203  *
 204  * @params[in] void **buf,Buffer to which encoded pattern is written into
 205  * @params[in] int *size,size of buffer
 206  *
 207  * @return ROK     - success
 208  *         RFAILED - failure
 209  *
 210  * ****************************************************************/
 211 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 212 {
 213    uint8_t    idx,ieIdx;
 214    uint8_t    elementCnt,cellCnt;
 215    F1AP_PDU_t         *f1apMsg = NULL;
 216    F1SetupResponse_t  *f1SetupRsp;
 217    GNB_CU_Name_t      *cuName;
 218    Cells_to_be_Activated_List_t *cellToActivate;
 219    RRC_Version_t      *rrcVer;
 220    asn_enc_rval_t     encRetVal;
 221    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 222
 223    /* Allocate the memory for F1SetupRequest_t */
 224    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 225    if(f1apMsg == NULLP)
 226    {
 227       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 228       return RFAILED;
 229    }
 230    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 231
 232    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 233    if(f1apMsg->choice.successfulOutcome == NULLP)
 234    {
 235       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 236       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 237       return RFAILED;
 238    }
 239
 240    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 241    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 242    f1apMsg->choice.successfulOutcome->value.present = \
 243                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 244    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 245
 246    elementCnt = 4;
 247    f1SetupRsp->protocolIEs.list.count = elementCnt;
 248    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 249
 250    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 251          elementCnt * sizeof(F1SetupResponseIEs_t *));
 252    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 253    {
 254       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 255       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 256       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 257       return RFAILED;
 258    }
 259
 260    for(idx=0; idx<elementCnt; idx++)
 261    {
 262       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 263             sizeof(F1SetupResponseIEs_t));
 264       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 265       {
 266          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 267                elementCnt * sizeof(F1SetupResponseIEs_t *));
 268          CU_FREE(f1apMsg->choice.successfulOutcome, \
 269                sizeof(SuccessfulOutcome_t));
 270          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 271          return RFAILED;
 272       }
 273    }
 274
 275    /*TransactionID*/
 276    idx = 0;
 277    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 278    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 279    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 280                                                             F1SetupResponseIEs__value_PR_TransactionID;
 281    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 282                                                                         TRANS_ID;
 283
 284    /*CU Name*/
 285    idx++;
 286    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 287    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 288    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 289                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 290    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 291    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 292
 293    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 294    if(cuName->buf == NULLP)
 295    {
 296       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 297       {
 298          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 299                sizeof(F1SetupResponseIEs_t));
 300       }
 301       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 302             elementCnt * sizeof(F1SetupResponseIEs_t *));
 303       CU_FREE(f1apMsg->choice.successfulOutcome,\
 304             sizeof(SuccessfulOutcome_t));
 305       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 306       return RFAILED;
 307    }
 308    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 309
 310    /*Cells to be activated list*/
 311    idx++;
 312    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 313                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 314    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 315    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 316                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 317    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 318                     Cells_to_be_Activated_List;
 319    cellCnt=1;
 320    cellToActivate->list.count = cellCnt;
 321    cellToActivate->list.size = \
 322                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 323    CU_ALLOC(cellToActivate->list.array,\
 324          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 325    if(cellToActivate->list.array == NULLP)
 326    {
 327       CU_FREE(cuName->buf, sizeof(cuName->size));
 328       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 329       {
 330          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 331                sizeof(F1SetupResponseIEs_t));
 332       }
 333       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 334             elementCnt * sizeof(F1SetupResponseIEs_t *));
 335       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 336       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 337       return RFAILED;
 338    }
 339    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 340    {
 341       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 342       if(cellToActivate->list.array[ieIdx] == NULLP)
 343       {
 344          CU_FREE(cellToActivate->list.array,\
 345                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 346          CU_FREE(cuName->buf, sizeof(cuName->size));
 347          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 348          {
 349             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 350                   sizeof(F1SetupResponseIEs_t));
 351          }
 352          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 353                elementCnt * sizeof(F1SetupResponseIEs_t *));
 354          CU_FREE(f1apMsg->choice.successfulOutcome, \
 355                sizeof(SuccessfulOutcome_t));
 356          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 357          return RFAILED;
 358       }
 359    }
 360    cellToActivate->list.array[0]->id = \
 361                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 362    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 363    cellToActivate->list.array[0]->value.present = \
 364                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 365    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 366       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 367    CU_ALLOC(cellToActivate->list.array[0]->\
 368          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 369          3*sizeof(uint8_t));
 370    if(cellToActivate->list.array[0]->value.choice.\
 371          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 372    {
 373
 374       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 375       {
 376          CU_FREE(cellToActivate->list.array[ieIdx],\
 377                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 378       }
 379
 380       CU_FREE(cellToActivate->list.array,\
 381             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 382       CU_FREE(cuName->buf, sizeof(cuName->size));
 383       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 384       {
 385          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 386                sizeof(F1SetupResponseIEs_t));
 387       }
 388       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 389             elementCnt * sizeof(F1SetupResponseIEs_t *));
 390       CU_FREE(f1apMsg->choice.successfulOutcome, \
 391             sizeof(SuccessfulOutcome_t));
 392       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 393       return RFAILED;
 394    }
 395    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 396          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 397    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 398       nRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
 399    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 400          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 401          cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 402          nRCGI.nRCellIdentity.size);
 403    if(cellToActivate->list.array[0]->value.choice.\
 404          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 405    {
 406       CU_FREE(cellToActivate->list.array[0]->\
 407             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 408             3*sizeof(uint8_t));
 409       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 410       {
 411          CU_FREE(cellToActivate->list.array[ieIdx],\
 412                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 413       }
 414
 415       CU_FREE(cellToActivate->list.array,\
 416             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 417       CU_FREE(cuName->buf, sizeof(cuName->size));
 418       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 419       {
 420          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 421                sizeof(F1SetupResponseIEs_t));
 422       }
 423       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 424             elementCnt * sizeof(F1SetupResponseIEs_t *));
 425       CU_FREE(f1apMsg->choice.successfulOutcome, \
 426             sizeof(SuccessfulOutcome_t));
 427       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 428       return RFAILED;
 429    }
 430    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 431    /* RRC Version */
 432    idx++;
 433    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 434                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 435    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 436    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 437                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 438    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 439    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 440
 441    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 442    if(rrcVer->latest_RRC_Version.buf == NULLP)
 443    {
 444       CU_FREE(cuName->buf, sizeof(cuName->size));
 445       for(ieIdx=0; ieIdx<elementCnt; idx++)
 446       {
 447          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 448                sizeof(F1SetupResponseIEs_t));
 449       }
 450       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 451             elementCnt * sizeof(F1SetupResponseIEs_t *));
 452       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 453       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 454       return RFAILED;
 455    }
 456
 457    /* Need to check RRC Version */
 458    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 459    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 460    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 461    if(rrcVer->iE_Extensions == NULLP)
 462    {
 463       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 464       CU_FREE(cuName->buf, sizeof(cuName->size));
 465       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 466       {
 467          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 468                sizeof(F1SetupResponseIEs_t));
 469       }
 470       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 471             elementCnt * sizeof(F1SetupResponseIEs_t *));
 472       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 473       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 474       return RFAILED;
 475    }
 476    rrcVer->iE_Extensions->list.count = 1;
 477    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 478    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 479          sizeof(struct RRC_Version_ExtIEs *));
 480    if(rrcVer->iE_Extensions->list.array == NULLP)
 481    {
 482       CU_FREE(rrcVer->iE_Extensions,\
 483             sizeof(ProtocolExtensionContainer_4624P81_t));
 484       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 485       CU_FREE(cuName->buf, sizeof(cuName->size));
 486       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 487       {
 488          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 489                sizeof(F1SetupResponseIEs_t));
 490       }
 491       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 492             elementCnt * sizeof(F1SetupResponseIEs_t *));
 493       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 494       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 495       return RFAILED;
 496    }
 497    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 498          sizeof(struct RRC_Version_ExtIEs));
 499    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 500    {
 501       CU_FREE(rrcVer->iE_Extensions->list.array,\
 502             sizeof(struct RRC_Version_ExtIEs *));
 503       CU_FREE(rrcVer->iE_Extensions,\
 504             sizeof(ProtocolExtensionContainer_4624P81_t));
 505       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 506       CU_FREE(cuName->buf, sizeof(cuName->size));
 507       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 508       {
 509          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 510                sizeof(F1SetupResponseIEs_t));
 511       }
 512       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 513             elementCnt * sizeof(F1SetupResponseIEs_t *));
 514       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 515       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 516       return RFAILED;
 517    }
 518    rrcVer->iE_Extensions->list.array[0]->id = \
 519                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 520    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 521    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 522                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 523    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 524       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 525    CU_ALLOC(rrcVer->iE_Extensions->list.\
 526          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 527          3*sizeof(uint8_t));
 528    if(rrcVer->iE_Extensions->list.\
 529          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 530    {
 531       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 532             sizeof(struct RRC_Version_ExtIEs));
 533       CU_FREE(rrcVer->iE_Extensions->list.array,\
 534             sizeof(struct RRC_Version_ExtIEs *));
 535       CU_FREE(rrcVer->iE_Extensions,\
 536             sizeof(ProtocolExtensionContainer_4624P81_t));
 537       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 538       CU_FREE(cuName->buf, sizeof(cuName->size));
 539       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 540       {
 541          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 542                sizeof(F1SetupResponseIEs_t));
 543       }
 544       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 545             elementCnt * sizeof(F1SetupResponseIEs_t *));
 546       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 547       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 548       return RFAILED;
 549    }
 550    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 551       Latest_RRC_Version_Enhanced.buf[0] = 0;
 552    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 553       Latest_RRC_Version_Enhanced.buf[1] = 5;
 554    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 555       Latest_RRC_Version_Enhanced.buf[2] = 15;
 556
 557    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 558
 559    /* Encode the F1SetupRequest type as UPER */
 560    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 561    encBufSize = 0;
 562    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 563
 564    /* Clean up */
 565    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 566    CU_FREE(cuName->buf, sizeof(cuName->size));
 567    for(idx=0; idx<elementCnt; idx++)
 568    {
 569       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 570    }
 571    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 572    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 573    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 574
 575    /* Check encode results */
 576    if(encRetVal.encoded == ENCODE_FAIL)
 577    {
 578       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 579             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 580       return RFAILED;
 581    }
 582    else
 583    {
 584       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 585       for(int i=0; i< encBufSize; i++)
 586       {
 587          DU_LOG("%x",encBuf[i]);
 588       }
 589    }
 590
 591    /* Sending msg */
 592    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 593    {
 594       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 595       return RFAILED;
 596    }
 597
 598    return ROK;
 599 }/* End of BuildAndSendF1SetupRsp */
 600
 601 /*******************************************************************
 602  *
 603  * @brief Builds and sends the DUUpdateAcknowledge
 604  *
 605  * @details
 606  *
 607  *    Function : BuildAndSendDUUpdateAck
 608  *
 609  *    Functionality: Constructs the DU Update Acknowledge message and sends
 610  *                   it to the DU through SCTP.
 611  *
 612  * @params[in]
 613  *
 614  * @return ROK     - success
 615  *         RFAILED - failure
 616  *
 617  * ****************************************************************/
 618
 619 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 620 {
 621    uint8_t   idx;
 622    uint8_t   elementCnt;
 623    F1AP_PDU_t *f1apMsg = NULL;
 624    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 625    asn_enc_rval_t enRetVal; /* Encoder return value */
 626
 627    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 628
 629    /* Allocate the memory for F1SetupRequest_t */
 630    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 631    if(f1apMsg == NULLP)
 632    {
 633       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 634       return RFAILED;
 635    }
 636
 637    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 638
 639    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 640    if(f1apMsg->choice.successfulOutcome == NULLP)
 641    {
 642       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 643       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 644       return RFAILED;
 645    }
 646
 647    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 648    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 649    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 650    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 651
 652    elementCnt = 1;
 653    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 654    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 655
 656    /* Initialize the F1Setup members */
 657    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 658    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 659    {
 660       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 661       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 662       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 663       return RFAILED;
 664    }
 665
 666    for(idx=0; idx<elementCnt; idx++)
 667    {
 668       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 669       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 670       {
 671          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 672          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 673          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 674          return RFAILED;
 675       }
 676    }
 677
 678    /*TransactionID*/
 679    idx = 0;
 680    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 681    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 682    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 683    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 684    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 685
 686    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 687
 688    /* Encode the F1SetupRequest type as UPER */
 689    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 690    encBufSize = 0;
 691    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 692
 693    /* Clean up */
 694    for(idx=0; idx<elementCnt; idx++)
 695    {
 696       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 697    }
 698    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 699    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 700    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 701
 702    /* Checking encode results */
 703    if(enRetVal.encoded == ENCODE_FAIL)
 704    {
 705       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 706       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 707       return RFAILED;
 708    }
 709    else
 710    {
 711       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 712       for(int i=0; i< encBufSize; i++)
 713       {
 714          DU_LOG("%x",encBuf[i]);
 715       }
 716    }
 717
 718    /* Sending msg */
 719    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 720    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 721    {
 722       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 723       return RFAILED;
 724    }
 725
 726    return ROK;
 727
 728 }/* End of BuildAndSendDUUpdateAck*/
 729
 730 /*******************************************************************
 731 *
 732 * @brief deallocating the memory of  F1reset msg
 733 *
 734 * @details
 735 *
 736 *    Function : FreeF1ResetReq
 737 *
 738 *    Functionality :
 739 *         - freeing memory of F1reset request msg
 740 *
 741 * @params[in]
 742 * @return void
 743 *
 744 *
 745 * ****************************************************************/
 746 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 747 {
 748    uint8_t idx = 0;
 749    Reset_t *f1ResetMsg = NULLP;
 750
 751    if(f1apMsg)
 752    {
 753       if(f1apMsg->choice.initiatingMessage)
 754       {
 755          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 756          if(f1ResetMsg->protocolIEs.list.array)
 757          {
 758             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 759             {
 760                if(f1ResetMsg->protocolIEs.list.array[idx])
 761                {
 762                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 763                }
 764             }
 765             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 766          }
 767          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 768       }
 769       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 770    }
 771 }
 772 /*******************************************************************
 773  *
 774  * @brief build ansld ans send f1reset msg
 775  *
 776  * @details
 777  *
 778  *    Function : BuildAndSendF1ResetReq
 779  *
 780  *    Functionality: build and send f1reset msg
 781  *
 782  * @return ROK     - success
 783  *         RFAILED - failure
 784  *
 785  * ****************************************************************/
 786 uint8_t BuildAndSendF1ResetReq()
 787 {
 788    uint8_t          elementCnt=0;
 789    uint8_t          idx=0;
 790    uint8_t          ret= RFAILED;
 791    Reset_t          *f1ResetMsg = NULLP;
 792    F1AP_PDU_t       *f1apMsg = NULLP;
 793    asn_enc_rval_t   encRetVal;
 794    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 795    do
 796    {
 797       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 798       if(f1apMsg == NULLP)
 799       {
 800          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 801          break;
 802       }
 803       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 804       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 805       if(f1apMsg->choice.initiatingMessage == NULLP)
 806       {
 807          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 808          break;
 809       }
 810       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 811       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 812       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 813
 814       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 815
 816       elementCnt = 3;
 817       f1ResetMsg->protocolIEs.list.count = elementCnt;
 818       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 819
 820       /* Initialize the F1Reset members */
 821       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 822       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 823       {
 824          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 825          break;
 826       }
 827       for(idx=0; idx<elementCnt; idx++)
 828       {
 829          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 830          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 831          {
 832             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 833             break;
 834          }
 835       }
 836
 837       /*TransactionID*/
 838       idx=0;
 839       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 840       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 841       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 842       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 843
 844       /*Cause*/
 845       idx++;
 846       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 847       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 848       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 849       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 850       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 851
 852       /*Reset Type*/
 853       idx++;
 854       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 855       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 856       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 857       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 858       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 859
 860       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 861
 862       /* Encode the F1SetupRequest type as APER */
 863       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 864       encBufSize = 0;
 865       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 866             encBuf);
 867
 868       /* Encode results */
 869       if(encRetVal.encoded == ENCODE_FAIL)
 870       {
 871          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 872                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 873          break;
 874       }
 875       else
 876       {
 877          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 878          for(idx=0; idx< encBufSize; idx++)
 879          {
 880             DU_LOG("%x",encBuf[idx]);
 881          }
 882       }
 883
 884       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 885       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 886       {
 887          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 888          break;
 889       }
 890
 891       ret = ROK;
 892       break;
 893    }while(true);
 894
 895    FreeF1ResetReq(f1apMsg);
 896    return ret;
 897 }
 898
 899 /*******************************************************************
 900  *
 901  * @brief Fills Radio Bearer Config
 902  *
 903  * @details
 904  *
 905  *    Function : fillSrbCfg
 906  *
 907  *    Functionality: Fills Radio Bearer Config
 908  *
 909  * @params[in] SRB_ToAddModList *
 910  *
 911  * @return ROK     - success
 912  *         RFAILED - failure
 913  *
 914  * ****************************************************************/
 915 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 916 {
 917    uint8_t elementCnt = 0;
 918    uint8_t idx, ieId, srbIdx = 0;
 919
 920    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 921    {
 922       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 923          elementCnt++;
 924    }
 925
 926    if(bearerCfg != NULLP)
 927    {
 928       bearerCfg->list.count = elementCnt;
 929       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 930       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 931       if(bearerCfg->list.array != NULLP)
 932       {
 933          for(idx = 0; idx < elementCnt; idx++)
 934          {
 935             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 936             if(bearerCfg->list.array[idx] == NULLP)
 937             {
 938                for(ieId = 0; ieId < idx; ieId++)
 939                {
 940                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 941                }
 942                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 943                return RFAILED;
 944             }
 945          }
 946       }
 947       else
 948       {
 949          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 950          return RFAILED;
 951       }
 952
 953       idx = 0;
 954       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 955       {
 956          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 957             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 958       }
 959    }
 960    return ROK;
 961 }
 962
 963 /*******************************************************************
 964  *
 965  * @brief Fills Master CellGroup Info
 966  *
 967  * @details
 968  *
 969  *    Function : fillMasterCellGroup
 970  *
 971  *    Functionality: Fills Master Cell Group IE
 972  *
 973  * @params[in] RRCSetup_IEs_t *
 974  *
 975  * @return ROK     - success
 976  *         RFAILED - failure
 977  *
 978  * ****************************************************************/
 979
 980 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 981 {
 982    uint8_t ret = ROK;
 983    masterCellGroup->buf = NULLP;
 984    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 985    {
 986       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 987       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 988       if(masterCellGroup->buf != NULLP)
 989       {
 990          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
 991       }
 992       else
 993       {
 994          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
 995          ret = RFAILED;
 996       }
 997    }
 998    else
 999    {
1000       ret =  RFAILED;
1001    }
1002    return ret;
1003 }
1004
1005 /*******************************************************************
1006  *
1007  * @brief Fills RRC setup IE
1008  *
1009  * @details
1010  *
1011  *    Function : fillRRCSetupIE
1012  *
1013  *    Functionality: Fills RRC Setup IE
1014  *
1015  * @params[in] RRCSetup_IEs_t *
1016  *
1017  * @return ROK     - success
1018  *         RFAILED - failure
1019  *
1020  * ****************************************************************/
1021
1022 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1023 {
1024    uint8_t ret = ROK, srbIdx = 0;
1025    if(rrcSetupIE)
1026    {
1027       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1028       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1029       {
1030          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1031       }
1032       if(ret == ROK)
1033       {
1034          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1035       }
1036       else
1037       {
1038          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1039          ret = RFAILED;
1040       }
1041
1042       /* If SRB configuration are filled successfully in RRC Setup, mark these
1043        * configurartion as sent to UE */
1044       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1045       {
1046          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1047             ueCb->srbList[srbIdx].cfgSentToUe = true;
1048       }
1049    }
1050    return ret;
1051 }
1052 /*******************************************************************
1053  *
1054  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1055  *
1056  * @details
1057  *
1058  *    Function : fillDlCcchRrcMsg
1059  *
1060  *    Functionality: Fills DL DCCCH Message required for
1061  *                   DLRRCMessageTransfer
1062  *
1063  * @params[in] RRCContainer_t *rrcContainer
1064  *
1065  * @return ROK     - success
1066  *         RFAILED - failure
1067  *
1068  * ****************************************************************/
1069
1070 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1071 {
1072    uint8_t ret = ROK;
1073    uint16_t idx2;
1074    DL_CCCH_Message_t dl_CCCH_Msg;
1075    asn_enc_rval_t    encRetVal;
1076
1077    if(rrcContainer != NULLP)
1078    {
1079       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1080
1081       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1082       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1083       {
1084          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1085          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1086          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1087          {
1088             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1089             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1090                RRCSetup__criticalExtensions_PR_rrcSetup;
1091
1092             /* Fill RRC Setup IE */
1093             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1094                sizeof(RRCSetup_IEs_t));
1095             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1096             {
1097                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1098
1099                if(ret == ROK)
1100                {
1101                   /* encode DL-CCCH message into RRC Container */
1102                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1103                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1104                   encBufSize = 0;
1105                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1106                   /* Encode results */
1107                   if(encRetVal.encoded == ENCODE_FAIL)
1108                   {
1109                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1110                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1111                      return RFAILED;
1112                   }
1113                   else
1114                   {
1115                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1116                      for(int i = 0; i< encBufSize; i++)
1117                      {
1118                         DU_LOG("%x",encBuf[i]);
1119                      }
1120                      rrcContainer->size = encBufSize;
1121                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1122                      if(rrcContainer->buf != NULLP)
1123                      {
1124                         memset(rrcContainer->buf, 0, encBufSize);
1125                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1126                         {
1127                            rrcContainer->buf[idx2] =    encBuf[idx2];
1128                         }
1129                      }
1130                   }
1131                }
1132                else
1133                {
1134                   ret = RFAILED;
1135                }
1136             }
1137             else
1138             {
1139                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1140                ret = RFAILED;
1141             }
1142          }
1143          else
1144          {
1145             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1146             ret = RFAILED;
1147          }
1148       }
1149       else
1150       {
1151          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1152          ret = RFAILED;
1153       }
1154    }
1155    else
1156    {
1157       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1158       ret = RFAILED;
1159    }
1160 }
1161
1162 /*******************************************************************
1163  *
1164  * @brief Fills QOS flow configuration
1165  *
1166  * @details
1167  *
1168  *    Function : fillQosFlowsToAdd
1169  *
1170  *    Functionality: Fills QOS flow configuration
1171  *
1172  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1173  *
1174  * @return ROK     - success
1175  *         RFAILED - failure
1176  *
1177  * ****************************************************************/
1178 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1179 {
1180    uint8_t idx, ied, elementCnt;
1181
1182    elementCnt = 1;
1183    qosFlow->list.count = elementCnt;
1184    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1185    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1186    if(qosFlow->list.array != NULLP)
1187    {
1188       for(idx = 0; idx < elementCnt; idx++)
1189       {
1190          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1191          if(qosFlow->list.array[idx] == NULLP)
1192          {
1193             for(ied = 0; ied < idx; ied++)
1194             {
1195                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1196             }
1197             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1198             return RFAILED;
1199          }
1200       }
1201    }
1202    idx = 0;
1203    *qosFlow->list.array[idx] = 9;
1204    return ROK;
1205 }
1206
1207 /*******************************************************************
1208  *
1209  * @brief Fills CN Assoc for Drb to Add/Mod List
1210  *
1211  * @details
1212  *
1213  *    Function : fillCnAssoc
1214  *
1215  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1216  *
1217  * @params[in] struct DRB_ToAddMod__cnAssociation *
1218  *
1219  * @return ROK     - success
1220  *         RFAILED - failure
1221  *
1222  * ****************************************************************/
1223
1224 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1225 {
1226    uint8_t ret = ROK;
1227
1228    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1229    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1230    {
1231       cnAssoc->choice.eps_BearerIdentity = 5;
1232    }
1233    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1234    {
1235       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1236       if(cnAssoc->choice.sdap_Config)
1237       {
1238          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1239          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1240          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1241          cnAssoc->choice.sdap_Config->defaultDRB = true;
1242          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1243          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1244          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1245                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1246          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1247          {
1248             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1249          }
1250          else
1251          {
1252             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1253             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1254             ret = RFAILED;
1255          }
1256       }
1257       else
1258       {
1259          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1260          ret = RFAILED;
1261       }
1262    }
1263    return ret;
1264 }
1265
1266 /*******************************************************************
1267  *
1268  * @brief Fills Radio Bearer Config for Drb
1269  *
1270  * @details
1271  *
1272  *    Function : fillDrbCfg
1273  *
1274  *    Functionality: Fills Radio Bearer Config for Drb
1275  *
1276  * @params[in] drbId, DRB_ToAddModList *
1277  *
1278  * @return ROK     - success
1279  *         RFAILED - failure
1280  *
1281  * ****************************************************************/
1282 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1283 {
1284    uint8_t idx, ied, ret, elementCnt;
1285
1286    ret = ROK;
1287    if(drbCfg != NULLP)
1288    {
1289       elementCnt = 1;
1290       drbCfg->list.count = elementCnt;
1291       drbCfg->list.size =\
1292                          elementCnt * sizeof(DRB_ToAddMod_t *);
1293       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1294       if(drbCfg->list.array != NULLP)
1295       {
1296          for(idx = 0; idx < elementCnt; idx++)
1297          {
1298             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1299             if(drbCfg->list.array[idx] == NULLP)
1300             {
1301                for(ied = 0; ied < idx; ied++)
1302                {
1303                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1304                }
1305                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1306                return RFAILED;
1307             }
1308          }
1309       }
1310       else
1311       {
1312          return RFAILED;
1313       }
1314       idx = 0;
1315       /* CN ASSOCIATION */
1316       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1317       if(drbCfg->list.array[idx]->cnAssociation)
1318       {
1319          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1320       }
1321       /* DRB */
1322       drbCfg->list.array[idx]->drb_Identity = drbId;
1323    }
1324    return ret;
1325 }
1326
1327 /*******************************************************************
1328  *
1329  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1330  *
1331  * @details
1332  *
1333  *    Function : fillRrcReconfigIE
1334  *
1335  *    Functionality: Fills RRC Reconfig Message required for
1336  *                   DLRRCMessageTransfer
1337  *
1338  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1339  *
1340  * @return ROK     - success
1341  *         RFAILED - failure
1342  *
1343  * ****************************************************************/
1344
1345 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1346 {
1347    uint8_t ret = ROK;
1348    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1349    if(rrcReconfigMsg->radioBearerConfig)
1350    {
1351       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1352       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1353       {
1354          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1355
1356       }
1357       if(ret == ROK)
1358       {
1359          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1360          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1361          {
1362             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1363             if(ret == RFAILED)
1364             {
1365                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1366                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1367                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1368             }
1369          }
1370       }
1371       else
1372       {
1373          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1374          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1375       }
1376    }
1377
1378    return ret;
1379 }
1380 /*******************************************************************
1381  *
1382  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1383  *
1384  * @details
1385  *
1386  *    Function : fillDlDcchRrcMsg
1387  *
1388  *    Functionality: Fills DL DCCH Message required for
1389  *                   DLRRCMessageTransfer
1390  *
1391  * @params[in] RRCContainer_t *rrcContainer
1392  *
1393  * @return ROK     - success
1394  *         RFAILED - failure
1395  *
1396  * ****************************************************************/
1397
1398 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1399 {
1400    uint8_t ret = ROK;
1401    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1402    DL_DCCH_Message_t dl_DCCH_Msg;
1403    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1404    asn_enc_rval_t        encRetVal;
1405
1406    if(rrcContainer != NULLP)
1407    {
1408       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1409
1410       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1411       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1412       {
1413          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1414          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1415          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1416          {
1417             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1418             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1419             if(ret == ROK)
1420             {
1421                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1422                 * configurartion as sent to UE */
1423                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1424                {
1425                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1426                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1427                }
1428                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1429                {
1430                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1431                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1432                }
1433
1434                /* encode DL-DCCH message into RRC Container */
1435                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1436                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1437                encBufSize = 0;
1438                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1439                /* Encode results */
1440                if(encRetVal.encoded == ENCODE_FAIL)
1441                {
1442                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1443                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1444                   return RFAILED;
1445                }
1446                else
1447                {
1448                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1449                   for(int i = 0; i< encBufSize; i++)
1450                   {
1451                      DU_LOG("%x",encBuf[i]);
1452                   }
1453                   rrcContainer->size = encBufSize;
1454                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1455                   if(rrcContainer->buf != NULLP)
1456                   {
1457                      memset(rrcContainer->buf, 0, encBufSize);
1458                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1459                      {
1460                         rrcContainer->buf[idx2] =       encBuf[idx2];
1461                      }
1462                   }
1463                }
1464             }
1465          }
1466          else
1467          {
1468             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1469             ret = RFAILED;
1470          }
1471       }
1472       else
1473       {
1474          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1475          ret = RFAILED;
1476       }
1477    }
1478    else
1479    {
1480       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1481       ret = RFAILED;
1482    }
1483    return ret;
1484 }
1485
1486 /*******************************************************************
1487  *
1488  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1489  *
1490  * @details
1491  *
1492  *    Function : BuildDLRRCContainer
1493  *
1494  *    Functionality: Builds RRC Container IE required for
1495  *                   DLRRCMessageTransfer
1496  *
1497  * @params[in]
1498  *
1499  * @return ROK     - success
1500  *         RFAILED - failure
1501  *
1502  * ****************************************************************/
1503
1504 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1505 {
1506    uint8_t ret, bufLen;
1507
1508    ret =ROK;
1509    if(rrcMsgType == RRC_SETUP)
1510    {
1511       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1512       if(ret == RFAILED)
1513          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1514    }
1515    else if(rrcMsgType == RRC_SETUP_COMPLETE)
1516    {
1517       DU_LOG("\nINFO --> F1AP : Sending Security mode command");
1518       char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1519       bufLen =9;
1520       rrcContainer->size = bufLen;
1521       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1522       if(rrcContainer->buf != NULLP)
1523       {
1524          memset(rrcContainer->buf, 0, bufLen);
1525          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1526       }
1527       else
1528       {
1529          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1530          ret = RFAILED;
1531       }
1532    }
1533    else if(rrcMsgType == SECURITY_MODE_COMPLETE)
1534    {
1535       /*Hardcoded RRC Container from reference logs*/
1536       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1537       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1538       bufLen =14;
1539       rrcContainer->size = bufLen;
1540       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1541       if(rrcContainer->buf != NULLP)
1542       {
1543          memset(rrcContainer->buf, 0, bufLen);
1544          memcpy(rrcContainer->buf, buf, bufLen);
1545       }
1546       else
1547       {
1548          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1549          ret = RFAILED;
1550       }
1551    }
1552    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1553    {
1554       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1555       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1556       if(ret == RFAILED)
1557          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1558    }
1559
1560    return ret;
1561 }
1562
1563 /*******************************************************************
1564  *
1565  * @brief Frees the DLRRCMessageTransfer
1566  *
1567  * @details
1568  *
1569  *    Function : freeDlRrcMessageTransfer
1570  *
1571  *    Functionality: Frees the DLRRCMessageTransfer
1572  *
1573  * @params[in]
1574  *
1575  * @return ROK     - success
1576  *         RFAILED - failure
1577  *
1578  * ****************************************************************/
1579 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1580 {
1581    uint8_t idx=0;
1582    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1583
1584    if(f1apMsg)
1585    {
1586       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1587       if(dlRRCMsg->protocolIEs.list.array)
1588       {
1589          idx = 3;
1590          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1591             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1592          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1593          {
1594             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1595          }
1596          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1597       }
1598       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1599    }
1600 }
1601
1602 /*******************************************************************
1603  *
1604  * @brief Builds and sends the DLRRCMessageTransfer
1605  *
1606  * @details
1607  *
1608  *    Function : BuildAndSendDLRRCMessageTransfer
1609  *
1610  *    Functionality: Constructs the DL RRC Message Transfer and sends
1611  *                   it to the CU through SCTP.
1612  *
1613  * @params[in]
1614  *
1615  * @return ROK     - success
1616  *         RFAILED - failure
1617  *
1618  * ****************************************************************/
1619 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1620 {
1621    uint8_t   elementCnt = 0;
1622    uint8_t  ieId;
1623    uint8_t  idx;
1624    F1AP_PDU_t  *f1apMsg = NULLP;
1625    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1626    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1627
1628    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1629
1630    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1631    if(f1apMsg == NULLP)
1632    {
1633       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1634       return RFAILED;
1635    }
1636
1637    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1638    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1639    if(f1apMsg->choice.initiatingMessage == NULLP)
1640    {
1641       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1642       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1643       return RFAILED;
1644    }
1645
1646    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1647    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1648    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1649    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1650
1651    elementCnt = 4;
1652    dlRRCMsg->protocolIEs.list.count = elementCnt;
1653    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1654
1655    /* Initialize the F1Setup members */
1656    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1657    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1658    {
1659       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1660       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1661       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1662       return RFAILED;
1663    }
1664
1665    for(idx=0; idx<elementCnt; idx++)
1666    {
1667       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1668       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1669       {
1670          for(ieId=0; ieId<idx; ieId++)
1671          {
1672             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1673          }
1674          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1675          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1676          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1677          return RFAILED;
1678       }
1679    }
1680
1681    /* GNB CU UE F1AP ID */
1682    idx = 0;
1683    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1684    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1685    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1686    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1687
1688    /* GNB DU UE F1AP ID */
1689    idx++;
1690    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1691    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1692    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1693    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1694
1695    /* SRBID */
1696    idx++;
1697    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1698    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1699    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1700    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1701
1702    /* RRCContainer */
1703    idx++;
1704    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1705    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1706    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1707    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1708
1709    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1710
1711    /* Encode the F1SetupRequest type as APER */
1712    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1713    encBufSize = 0;
1714    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1715          encBuf);
1716    /* Encode results */
1717    if(encRetVal.encoded == ENCODE_FAIL)
1718    {
1719       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1720             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1721       return RFAILED;
1722    }
1723    else
1724    {
1725       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1726       for(int i=0; i< encBufSize; i++)
1727       {
1728          DU_LOG("%x",encBuf[i]);
1729       }
1730    }
1731
1732    /* Sending  msg  */
1733    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1734    {
1735       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1736       return RFAILED;
1737    }
1738    freeDlRrcMessageTransfer(f1apMsg);
1739    return ROK;
1740 }/* End of BuildAndSendDLRRCMessageTransfer */
1741
1742 /*******************************************************************
1743  *
1744  * @brief Function to set the Dl RRC Msg Type
1745  *
1746  * @details
1747  *
1748  *    Function : setDlRRCMsgType
1749  *
1750  *    Functionality: Constructs the UE Setup Response and sends
1751  *                   it to the DU through SCTP.
1752  *
1753  * @params[in]
1754  *
1755  * @return ROK     - success
1756  *         RFAILED - failure
1757  *
1758  * ****************************************************************/
1759
1760 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1761 {
1762    uint8_t rrcMsgType = 0;
1763    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1764    {
1765       case RRC_SETUP:
1766          rrcMsgType = RRC_SETUP;
1767          break;
1768       case RRC_SETUP_COMPLETE:
1769          rrcMsgType = RRC_SETUP_COMPLETE;
1770          break;
1771       case SECURITY_MODE_COMPLETE:
1772          rrcMsgType = SECURITY_MODE_COMPLETE;
1773          break;
1774       case REGISTRATION_COMPLETE:
1775          rrcMsgType = REGISTRATION_COMPLETE;
1776          break;
1777       case UE_CONTEXT_SETUP_RSP:
1778          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1779          break;
1780       case RRC_RECONFIG_COMPLETE:
1781          rrcMsgType = RRC_RECONFIG_COMPLETE;
1782          break;
1783       default:
1784          break;
1785    }
1786    return rrcMsgType;
1787 }
1788
1789 #ifdef NR_DRX
1790 /*******************************************************************
1791  *
1792  * @brief fill long cycle offset value of drx
1793  *
1794  * @details
1795  *
1796  *    Function : fillLongCycleOffsetValue
1797  *
1798  *    Functionality: fill long cycle offset value of drx
1799  *
1800  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
1801  * struct DRX_ConfigRrc__drx_LongCycleStartOffset recvedLongCycleOffsetVal
1802  *
1803  * @return ROK     - success
1804  *         RFAILED - failure
1805  *
1806  * ****************************************************************/
1807 void fillLongCycleOffsetValue(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__recvedLongCycleOffsetVal  *recvedLongCycleOffsetVal)
1808 {
1809
1810    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = recvedLongCycleOffsetVal->present;
1811    switch(recvedLongCycleOffsetVal->present)
1812    {
1813       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms10:
1814          {
1815             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10;
1816             break;
1817          }
1818       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms20:
1819          {
1820             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms20;
1821             break;
1822          }
1823       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms32:
1824          {
1825             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms32;
1826             break;
1827          }
1828       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms40:
1829          {
1830             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms40;
1831             break;
1832          }
1833       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms60:
1834          {
1835             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms60;
1836             break;
1837          }
1838       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms64:
1839          {
1840             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms64;
1841             break;
1842          }
1843       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms70:
1844          {
1845             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms70;
1846             break;
1847          }
1848       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms80:
1849          {
1850             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms80;
1851             break;
1852          }
1853       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms128:
1854          {
1855             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms128;
1856             break;
1857          }
1858       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms160:
1859          {
1860             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms160;
1861             break;
1862          }
1863       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms256:
1864          {
1865             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms256;
1866             break;
1867          }
1868       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms320:
1869          {
1870             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms320;
1871             break;
1872          }
1873       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms512:
1874          {
1875             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms512;
1876             break;
1877          }
1878       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms640:
1879          {
1880             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms640;
1881             break;
1882          }
1883       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms1024:
1884          {
1885             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1024;
1886             break;
1887          }
1888       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms1280:
1889          {
1890             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1280;
1891             break;
1892          }
1893       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms2048:
1894          {
1895             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2048;
1896             break;
1897          }
1898       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms2560:
1899          {
1900             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2560;
1901             break;
1902          }
1903       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms5120:
1904          {
1905             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms5120;
1906             break;
1907          }
1908       case DRX_ConfigRrc__recvedLongCycleOffsetVal_PR_ms10240:
1909          {
1910             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10240;
1911             break;
1912          }
1913       default :
1914          break;
1915    }
1916 }
1917
1918 /*******************************************************************
1919  *
1920  * @brief Extract configuration from DRX_ConfigRrc
1921  *    and store the drx configuration in UeCb
1922  *
1923  * @details
1924  *
1925  *    Function : storeDrxCfgInUeCb
1926  *
1927  *    Functionality: Store drx configuration in UeCb
1928  *
1929  * @params[in] (struct DRX_ConfigRrc *setup, DrxCfg *drxCfg)
1930  *
1931  * @return void
1932  * ****************************************************************/
1933 void storeDrxCfgInUeCb(struct DRX_ConfigRrc *drxSetup, DrxCfg *drxCfg)
1934 {
1935    if(drxSetup)
1936    {
1937       switch(drxSetup->drx_onDurationTimer.present)
1938       {
1939          case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
1940             break;
1941          case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
1942             {
1943                drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
1944                drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=drxSetup->drx_onDurationTimer.choice.milliSeconds;
1945                break;
1946             }
1947          case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
1948             {
1949                drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
1950                drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = drxSetup->drx_onDurationTimer.choice.subMilliSeconds;
1951                break;
1952             }
1953       }
1954    }
1955    fillLongCycleOffsetValue(&drxCfg->drxLongCycleStartOffset, &drxSetup->drx_LongCycleStartOffset);
1956    drxCfg->drxInactivityTimer = drxSetup->drx_InactivityTimer;
1957    drxCfg->drxHarqRttTimerDl = drxSetup->drx_HARQ_RTT_TimerDL;
1958    drxCfg->drxHarqRttTimerUl = drxSetup->drx_HARQ_RTT_TimerUL;
1959    drxCfg->drxRetransmissionTimerDl = drxSetup->drx_RetransmissionTimerDL;
1960    drxCfg->drxRetransmissionTimerUl = drxSetup->drx_RetransmissionTimerUL;
1961    drxCfg->drxSlotOffset = drxSetup->drx_SlotOffset;
1962    if(drxSetup->shortDRX)
1963    {
1964       drxCfg->shortDrxPres=true;
1965       drxCfg->shortDrx.drxShortCycle = drxSetup->shortDRX->drx_ShortCycle;
1966       drxCfg->shortDrx.drxShortCycleTimer = drxSetup->shortDRX->drx_ShortCycleTimer;
1967    }
1968    else
1969       drxCfg->shortDrxPres=false;
1970 }
1971 #endif
1972
1973 /*******************************************************************
1974  *
1975  * @brief Extract configuration from CellGroupConfig
1976  *
1977  * @details
1978  *
1979  *    Function : extractCellGroupConfig
1980  *
1981  *    Functionality: Extract configuration from CellGroupConfig
1982  *        and store in local database
1983  *
1984  * @params[in] UE control block
1985  *             Cell Group Config
1986  *
1987  * @return ROK     - success
1988  *         RFAILED - failure
1989  *
1990  * ****************************************************************/
1991 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1992 {
1993    uint8_t rbIdx, srbIdx, drbIdx;
1994    bool    srbFound, drbFound;
1995    SrbInfo *srbCfgDb = NULLP;
1996    DrbInfo *drbCfgDb = NULLP;
1997    RlcLcCfg *rlcLcCfgDb = NULLP;
1998    MacLcCfg *macLcCfgDb = NULLP;
1999    RLC_BearerConfig_t *rlcCfg = NULLP;
2000    RLC_Config_t *rlcLcCfg = NULLP;
2001    LogicalChannelConfig_t *macLcCfg = NULLP;
2002 #ifdef NR_DRX
2003    DrxCfg    drxCfg;
2004 #endif
2005
2006    if(ueCb == NULLP)
2007    {
2008       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
2009       return RFAILED;
2010    }
2011
2012    if(cellGrpCfg == NULLP)
2013    {
2014       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
2015       return RFAILED;
2016    }
2017
2018 #ifdef NR_DRX
2019    if(cellGrpCfg->mac_CellGroupConfig)
2020    {
2021       if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc)
2022       {
2023          switch(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->present)
2024          {
2025             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
2026                break;
2027
2028             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
2029             {
2030                storeDrxCfgInUeCb(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup, &ueCb->drxCfg);
2031                break;
2032             }
2033
2034             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
2035                break;
2036          }
2037       }
2038    }
2039 #endif
2040
2041    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
2042    {
2043       srbFound = false;
2044       drbFound = false;
2045
2046       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
2047
2048       /* Update SRB configuration in local DB */
2049       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
2050       {
2051          /* Search if SRB entry is already present in DB */
2052          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
2053          {
2054             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
2055             {
2056               srbCfgDb = &ueCb->srbList[srbIdx];
2057               srbFound = true;
2058               break;
2059             }
2060          }
2061
2062          /* If not, add SRB to UE CB's SRB list */
2063          if(!srbFound)
2064          {
2065             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
2066             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
2067             ueCb->numSrb++;
2068          }
2069
2070          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2071          srbCfgDb->cfgSentToUe = false;
2072          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
2073          macLcCfgDb = &srbCfgDb->macLcCfg;
2074       }
2075
2076       /* Update DRB configuration in local DB */
2077       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
2078       {
2079          /* Search if DRB entry is already present in DB */
2080          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
2081          {
2082             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
2083             {
2084               drbCfgDb = &ueCb->drbList[drbIdx];
2085               drbFound = true;
2086               break;
2087             }
2088          }
2089
2090          /* If not, add DRB to UE CB's SRB list */
2091          if(!drbFound)
2092          {
2093             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
2094             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
2095             ueCb->numDrb++;
2096          }
2097
2098          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2099          drbCfgDb->cfgSentToUe = false;
2100          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
2101          macLcCfgDb = &drbCfgDb->macLcCfg;
2102       }
2103
2104
2105       /* Update RLC configuration for this RB */
2106       rlcLcCfg = rlcCfg->rlc_Config;
2107       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
2108       switch(rlcLcCfgDb->rlcMode)
2109       {
2110          case RLC_Config_PR_am:
2111             {
2112                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
2113                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
2114                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
2115                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
2116                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
2117
2118                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
2119                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
2120                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
2121                break;
2122             }
2123
2124          case RLC_Config_PR_um_Bi_Directional:
2125             {
2126                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
2127
2128                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
2129                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
2130                break;
2131             }
2132       }
2133
2134       /* Update MAC configuration for this LC */
2135       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
2136       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
2137       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
2138       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
2139       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
2140       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
2141    }
2142    return ROK;
2143 }
2144
2145 /*******************************************************************
2146  *
2147  * @brief Function to decode DU to CU RRC container
2148  *
2149  * @details
2150  *
2151  *    Function : extractDuToCuRrcCont
2152  *
2153  *    Functionality: Function to decode DU to CU RRC container
2154  *
2155  * @params[in] UE Cb
2156  *             RRC conatiner octect string to be decoded
2157  *
2158  * @return ROK     - success
2159  *         RFAILED - failure
2160  *
2161  * ****************************************************************/
2162 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
2163 {
2164    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
2165    asn_dec_rval_t rval; /* Decoder return value */
2166
2167    /* Copy the received container to UeCb */
2168    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
2169
2170    /* Decoding DU to CU RRC container octet string to cell group config */
2171    cellGrpCfgMsg = &cellGrpCfg;
2172    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
2173
2174    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
2175
2176    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2177    {
2178       DU_LOG("\nERROR  -->  F1AP : ASN decode failed in extractDuToCuRrcCont");
2179       return RFAILED;
2180    }
2181    printf("\n");
2182    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
2183
2184    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
2185    {
2186       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
2187       return RFAILED;
2188    }
2189
2190    return ROK;
2191 }
2192
2193 /*******************************************************************
2194  *
2195  * @brief Function to build Initial UL RRC Message
2196  *
2197  * @details
2198  *
2199  *    Function : procInitULRRCMsg
2200  *
2201  *    Functionality: Function to build Initial UL RRC Message
2202  *
2203  * @params[in]
2204  *
2205  * @return ROK     - success
2206  *         RFAILED - failure
2207  *
2208  * ****************************************************************/
2209
2210 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2211 {
2212    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2213    uint8_t ret =ROK;
2214    uint16_t cellIdx=0, nrCellId = 0;
2215    uint32_t crnti;
2216    DuDb     *duDb;
2217    CuCellCb *cellCb;
2218    CuUeCb   *ueCb;
2219    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2220
2221    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2222
2223    SEARCH_DU_DB(duIdx, duId, duDb);
2224    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2225
2226    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2227    {
2228       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2229       {
2230          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2231             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2232             break;
2233
2234          case ProtocolIE_ID_id_NRCGI:
2235             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2236             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2237             if(cellCb == NULLP)
2238                return RFAILED;
2239             break;
2240
2241          case ProtocolIE_ID_id_C_RNTI:
2242             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2243             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2244             {
2245                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2246                memset(ueCb, 0, sizeof(CuUeCb));
2247                ueCb->cellCb = cellCb;
2248                ueCb->crnti = crnti;
2249                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2250                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2251                ueCb->state = UE_ATTACH_IN_PROGRESS;
2252                (duDb->numUe)++;
2253
2254                cellCb->ueCb[cellCb->numUe] = ueCb;
2255                cellCb->numUe++;
2256             }
2257             break;
2258
2259          case ProtocolIE_ID_id_RRCContainer:
2260             break;
2261
2262          case ProtocolIE_ID_id_DUtoCURRCContainer:
2263             {
2264                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2265                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2266                {
2267                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2268                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2269                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2270                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2271                   {
2272                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2273                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2274                         ueCb->f1apMsgDb.duToCuContainer.size);
2275                   }
2276                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2277                   {
2278                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2279                      ret = RFAILED;
2280                   }
2281                }
2282                else
2283                {
2284                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2285                   ret = RFAILED;
2286                }
2287                break;
2288             }
2289
2290          default:
2291             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2292             break;
2293       }
2294       if(ret == RFAILED)
2295          break;
2296    }
2297
2298    if(ret == ROK)
2299    {
2300       ueCb->f1apMsgDb.dlRrcMsgCount++;
2301       rrcMsgType = setDlRRCMsgType(ueCb);
2302       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2303    }
2304    return ret;
2305 }
2306
2307 /*******************************************************************
2308  *
2309  * @brief Builds Nrcgi
2310  *
2311  * @details
2312  *
2313  *    Function : BuildNrcgi
2314  *
2315  *    Functionality: Building the PLMN ID and NR Cell id
2316  *
2317  * @params[in] NRCGI_t *nrcgi
2318  * @return ROK     - success
2319  *         RFAILED - failure
2320  *
2321  * ****************************************************************/
2322 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2323 {
2324    uint8_t ret;
2325    uint8_t unused_bits = 4;
2326    uint8_t byteSize = 5;
2327
2328    /* Allocate Buffer Memory */
2329    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2330    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2331    if(nrcgi->pLMN_Identity.buf == NULLP)
2332    {
2333       return RFAILED;
2334    }
2335    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2336
2337    if(ret != ROK)
2338    {
2339       return RFAILED;
2340    }
2341    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2342    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2343    if(nrcgi->nRCellIdentity.buf == NULLP)
2344    {
2345       return RFAILED;
2346    }
2347    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2348
2349    return ROK;
2350 }
2351 /*******************************************************************
2352  *
2353  * @brief Builds Special cell list for UE Setup Request
2354  *
2355  * @details
2356  *
2357  *    Function : BuildSplCellList
2358  *
2359  *    Functionality: Constructs the Special Cell list for UESetReq
2360  *
2361  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2362  *
2363  * @return ROK     - success
2364  *         RFAILED - failure
2365  *
2366  * ****************************************************************/
2367 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2368 {
2369    uint8_t  cellCnt;
2370    uint8_t  idx;
2371    uint8_t  ret;
2372    cellCnt = 1;
2373    spCellLst->list.count = cellCnt;
2374    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2375    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2376    if(spCellLst->list.array == NULLP)
2377    {
2378       return RFAILED;
2379    }
2380    for(idx=0; idx<cellCnt; idx++)
2381    {
2382       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2383       if(spCellLst->list.array[idx] == NULLP)
2384       {
2385          return RFAILED;
2386       }
2387    }
2388    idx = 0;
2389    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2390    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2391    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2392
2393    /* Special Cell ID -NRCGI */
2394    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2395    if(ret != ROK)
2396    {
2397       return RFAILED;
2398    }
2399    /*Special Cell Index*/
2400    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2401    return ROK;
2402 }/* End of BuildSplCellList*/
2403
2404 /*******************************************************************
2405  *
2406  * @brief Builds SRBS to be setup
2407  *
2408  * @details
2409  *
2410  *    Function : BuildSRBSetup
2411  *
2412  *    Functionality: Constructs the SRB's for UESetReq
2413  *
2414  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2415  *
2416  * @return ROK     - success
2417  *         RFAILED - failure
2418  *
2419  * ****************************************************************/
2420 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2421 {
2422    uint8_t idx;
2423    uint8_t srbCnt;
2424
2425    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2426       srbCnt = ueCb->numSrb;
2427    else
2428       srbCnt = 1;
2429    srbSet->list.count = srbCnt;
2430    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2431    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2432    if(srbSet->list.array == NULLP)
2433    {
2434       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2435       return RFAILED;
2436    }
2437
2438    for(idx=0; idx<srbCnt; idx++)
2439    {
2440       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2441       if(srbSet->list.array[idx] == NULLP)
2442       {
2443          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2444          return RFAILED;
2445       }
2446    }
2447
2448    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2449    {
2450       idx = 0;
2451       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2452       srbSet->list.array[idx]->criticality = Criticality_ignore;
2453       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2454       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2455       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2456       ueCb->numSrb++;
2457    }
2458    else
2459    {
2460       for(idx=0; idx<srbCnt; idx++)
2461       {
2462          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2463          srbSet->list.array[idx]->criticality = Criticality_ignore;
2464          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2465          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2466       }
2467    }
2468    return ROK;
2469 }/* End of BuildSRBSetup*/
2470
2471 /*******************************************************************
2472  *
2473  * @brief Builds QOS Info for DRB Setum Item
2474  *
2475  * @details
2476  *
2477  *    Function : BuildQOSInfo
2478  *
2479  *    Functionality: Constructs the QOS Info for DRB Setup Item
2480  *
2481  * @params[in] QoSInformation_t *qosinfo
2482  *             int16_t pduSessionID
2483  *
2484  * @return ROK     - success
2485  *         RFAILED - failure
2486  *
2487  * ****************************************************************/
2488 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2489 {
2490    uint8_t elementCnt = 0, qosCntIdx = 0;
2491    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2492
2493    /* NonDynamic5QIDescriptor */
2494    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2495    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2496    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2497    {
2498       return RFAILED;
2499    }
2500
2501    if(hoInProgress)
2502       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2503    else
2504    {
2505       /*FiveQI*/
2506       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2507          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2508       else
2509          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2510
2511       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2512    }
2513
2514    if(!hoInProgress)
2515    {
2516       /*AveragingWindow*/
2517       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2518       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2519       {
2520          return RFAILED;
2521       }
2522       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2523       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2524
2525       /*MaxDataBurstVolume*/
2526       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2527       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2528       {
2529          return RFAILED;
2530       }
2531       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2532       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2533    }
2534
2535    /*nRGRAN Allocation Retention Priority*/
2536    if(hoInProgress)
2537    {
2538       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2539       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2540       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2541    }
2542    else
2543    {
2544       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2545       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2546       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2547
2548       qosInfo->priorityLevel = PriorityLevel_lowest;
2549       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2550       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2551    }
2552
2553    /* PDU session ID */
2554    if(!hoInProgress)
2555    {
2556       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2557       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2558       {
2559          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2560          return ROK;
2561       }
2562
2563       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2564       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2565
2566       if(qosIeExt)
2567       {
2568          elementCnt = NUM_QOS_EXT;
2569          qosIeExt->list.count = elementCnt;
2570          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2571
2572          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2573          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2574
2575          if(qosIeExt->list.array == NULLP)
2576          {
2577             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2578             return  RFAILED;
2579          }
2580
2581          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2582          {
2583             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2584             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2585             {
2586                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2587                return  RFAILED;
2588             }
2589             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2590             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2591             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2592             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2593             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2594                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2595             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2596             qosInfo->pduSessionId = pduSessionID;
2597          }
2598       }
2599       else
2600       {
2601          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2602          return RFAILED;
2603       }
2604    }
2605    return ROK;
2606 }/*End of BuildQOSInfo*/
2607
2608 /*******************************************************************
2609  *
2610  * @brief Builds SNSSAI
2611  *
2612  * @details
2613  *
2614  *    Function : BuildSNSSAI
2615  *
2616  *    Functionality: Constructs the SNSSAI For DRB list
2617  *
2618  * @params[in] SNSSAI_t *snssai
2619  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2620  *
2621  * @return ROK     - success
2622  *         RFAILED - failure
2623  *
2624  * ****************************************************************/
2625 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2626 {
2627    /*SNSSAI*/
2628    /*ssT*/
2629    snssai->sST.size = sizeof(uint8_t);
2630    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2631    if(snssai->sST.buf == NULLP)
2632    {
2633       return RFAILED;
2634    }
2635    if(!hoInProgress)
2636       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2637    else
2638       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2639
2640    /*sD*/
2641    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2642    if(snssai->sD == NULLP)
2643    {
2644       return RFAILED;
2645    }
2646    snssai->sD->size = 3 * sizeof(uint8_t);
2647    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2648    if(snssai->sD->buf == NULLP)
2649    {
2650       return RFAILED;
2651    }
2652    if(!hoInProgress)
2653       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2654    else
2655       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2656
2657    if(!hoInProgress)
2658       drbInfo->snssai = snssaiToCopy;
2659    return ROK;
2660 }/*End of BuildSNSSAI*/
2661
2662 /*******************************************************************
2663  *
2664  * @brief Builds the flow map.
2665  *
2666  * @details
2667  *
2668  *    Function : BuildFlowsMap
2669  *
2670  *    Functionality: Constructs the flowmap For DRB list
2671  *
2672  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2673  *
2674  * @return ROK     - success
2675  *         RFAILED - failure
2676  *
2677  * ****************************************************************/
2678 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2679 {
2680    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2681    FlowsMapped *qosFlow;
2682
2683    if(!hoInProgress)
2684       flowCnt = 1;
2685    else
2686       flowCnt = drbInfo->numFlowMap;
2687    flowMap->list.count = flowCnt;
2688    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2689    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2690    if(flowMap->list.array == NULLP)
2691    {
2692       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2693       return RFAILED;
2694    }
2695    for(idx=0; idx<flowCnt; idx++)
2696    {
2697       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2698       if(flowMap->list.array[idx] == NULLP)
2699       {
2700          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2701          return RFAILED;
2702       }
2703
2704       if(!hoInProgress)
2705       {
2706          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2707          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2708          {
2709             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2710             {
2711                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2712                {
2713                   qosFlow = &drbInfo->flowMapList[flowIdx];
2714                   break;
2715                }
2716             }
2717          }
2718          else
2719          {
2720             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2721             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2722          }
2723       }
2724       else
2725       {
2726          qosFlow = &drbInfo->flowMapList[idx];
2727          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2728       }
2729
2730       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2731             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2732       if(ret != ROK)
2733       {
2734          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2735          return RFAILED;
2736       }
2737
2738       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2739          drbInfo->numFlowMap++;
2740    }
2741    return ROK;
2742 }/*End of BuildFlowsMap*/
2743
2744 /*******************************************************************
2745  *
2746  * @brief Builds the Uplink Tunnel Info
2747  *
2748  * @details
2749  *
2750  *    Function : BuildULTnlInfo
2751  *
2752  *    Functionality: Constructs the UL TnlInfo For DRB list
2753  *
2754  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2755  *
2756  * @return ROK     - success
2757  *         RFAILED - failure
2758  *
2759  * ****************************************************************/
2760 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2761 {
2762    uint8_t idx;
2763    uint8_t ulCnt;
2764
2765    ulCnt = 1;
2766    ulInfo->list.count = ulCnt;
2767    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2768    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2769    if(ulInfo->list.array == NULLP)
2770    {
2771       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2772       return RFAILED;
2773    }
2774    for(idx=0; idx<ulCnt; idx++)
2775    {
2776       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2777       if(ulInfo->list.array[idx] == NULLP)
2778       {
2779          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2780               return RFAILED;
2781       }
2782    }
2783    idx = 0;
2784    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2785    /*GTP TUNNEL*/
2786    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2787    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2788    {
2789       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2790       return RFAILED;
2791    }
2792    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2793    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2794       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2795    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2796    {
2797       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2798       return RFAILED;
2799    }
2800
2801    if(!hoInProgress)
2802    {
2803       /* NOTE: Below IP address must be changed if running on different IP configuration */
2804       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2805       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2806       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2807       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2808       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2809
2810       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2811       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2812       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2813       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2814    }
2815    else
2816    {
2817       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2818       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2819       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2820       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2821       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2822    }
2823
2824    /*GTP TEID*/
2825    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2826    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2827       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2828    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2829    {
2830       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2831       return RFAILED;
2832    }
2833
2834    if(!hoInProgress)
2835    {
2836       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2837       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2838       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2839       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2840
2841       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2842       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2843       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2844       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2845    }
2846    else
2847    {
2848       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2849       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2850       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2851       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2852    }
2853    return ROK;
2854 }/*End of BuildULTnlInfo*/
2855
2856 /*******************************************************************
2857  *
2858  * @brief Builds DRBS to be setup
2859  *
2860  * @details
2861  *
2862  *    Function : BuildDRBSetup
2863  *
2864  *    Functionality: Constructs the DRB's for UESetReq
2865  *
2866  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2867  *
2868  * @return ROK     - success
2869  *         RFAILED - failure
2870  *
2871  * ****************************************************************/
2872 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2873 {
2874    uint16_t snssaiIdx=0;
2875    uint8_t idx = 0, extIeIdx = 0;
2876    uint8_t elementCnt = 0, drbCnt = 0;
2877    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2878    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2879    DRBs_ToBeSetup_Item_t *drbSetItem;
2880    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2881    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2882
2883    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2884       drbCnt = ueCb->numDrb;
2885    else
2886       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2887    drbSet->list.count = drbCnt;
2888
2889    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2890    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2891    if(drbSet->list.array == NULLP)
2892    {
2893       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2894       return RFAILED;
2895    }
2896
2897    for(idx=0; idx<drbCnt; idx++)
2898    {
2899       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2900       if(drbSet->list.array[idx] == NULLP)
2901       {
2902          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2903          return RFAILED;
2904       }
2905
2906       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2907       drbSet->list.array[idx]->criticality = Criticality_ignore;
2908       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2909       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2910       /*dRBID*/
2911       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2912       {
2913          drbSetItem->dRBID = idx + 1;
2914          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2915       }
2916       else
2917          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2918
2919       /*qoSInformation*/
2920       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2921       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2922       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2923       {
2924          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2925          return RFAILED;
2926       }
2927       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2928       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2929       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2930       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2931          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2932                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2933       else
2934          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2935                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2936       if(BuildQOSInforet != ROK)
2937       {
2938          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2939          return RFAILED;
2940       }
2941
2942       /*SNSSAI*/
2943       snssaiIdx = (idx% cuCb.numSnssaiSupported);
2944       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2945          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2946                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
2947       else
2948          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2949                choice_extension->value.choice.DRB_Information.sNSSAI, NULLP, TRUE);
2950       if(BuildSNSSAIret != ROK)
2951       {
2952          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2953          return RFAILED;
2954       }
2955
2956       /*Flows mapped to DRB List*/
2957       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2958          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2959                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2960       else
2961          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2962                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2963       if(BuildFlowsMapret != ROK)
2964       {
2965          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2966          return RFAILED;
2967       }
2968
2969       /*ULUPTNLInformation To Be Setup List*/
2970       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2971          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2972                FALSE);
2973       else
2974          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2975                TRUE);
2976       if(BuildULTnlInforet != ROK)
2977       {
2978          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2979          return RFAILED;
2980       }
2981
2982       /*RLCMode*/
2983       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2984       {
2985          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2986          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2987       }
2988       else
2989          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2990
2991       /* DL PDCP SN Length */
2992       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2993       {
2994          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2995          if(!drbToBeSetupExt)
2996          {
2997             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2998             return RFAILED;
2999          }
3000
3001          elementCnt = 1;
3002          drbToBeSetupExt->list.count = elementCnt;
3003          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
3004
3005          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
3006          if(!drbToBeSetupExt->list.array)
3007          {
3008              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
3009              return RFAILED;
3010          }
3011
3012          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
3013          {
3014             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
3015             if(!drbToBeSetupExt->list.array[extIeIdx])
3016             {
3017                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
3018                return RFAILED;
3019             }
3020          }
3021
3022          extIeIdx = 0;
3023          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
3024
3025          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
3026          drbToBeSetupExtIe->criticality = Criticality_ignore;
3027          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
3028          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
3029          drbSetItem->iE_Extensions = drbToBeSetupExt;
3030       }
3031
3032       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3033          ueCb->numDrb++;
3034    }
3035    return ROK;
3036 }/* End of BuildDRBSetup*/
3037
3038 /*******************************************************************
3039  *
3040  * @brief Deallocating memory of function BuildAndSendUESetReq
3041  *
3042  * @details
3043  *
3044  *    Function : FreeNrcgi
3045  *
3046  *    Functionality: Deallocating memory for function BuildNrcgi
3047  *
3048  * @params[in] NRCGI_t *nrcgi
3049  *
3050  * @return void
3051  *
3052  *******************************************************************/
3053 void FreeNrcgi(NRCGI_t *nrcgi)
3054 {
3055    if(nrcgi->pLMN_Identity.buf != NULLP)
3056    {
3057       if(nrcgi->nRCellIdentity.buf != NULLP)
3058       {
3059          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
3060       }
3061       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
3062    }
3063 }
3064 /*******************************************************************
3065  *
3066  * @brief  Deallocating memory of function BuildAndSendUESetReq
3067  *
3068  * @details
3069  *
3070  *    Function : FreeSplCellList
3071  *
3072  *    Functionality: Deallocating memory for function BuildSplCellList
3073  *
3074  * @params[in] SCell_ToBeSetup_List_t *spCellLst
3075  *
3076  * @return void
3077  *
3078  *
3079  * *****************************************************************/
3080 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
3081 {
3082    uint8_t  cellidx;
3083    if(spCellLst->list.array != NULLP)
3084    {
3085       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
3086       {
3087          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
3088          {
3089             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
3090          }
3091          if(spCellLst->list.array[cellidx]!=NULLP)
3092          {
3093             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
3094          }
3095       }
3096       CU_FREE(spCellLst->list.array,spCellLst->list.size);
3097    }
3098 }
3099 /*******************************************************************
3100  *
3101  * @brief Deallocating memory of function BuildAndSendUESetReq
3102  *
3103  * @details
3104  *
3105  *    Function : FreeSRBSetup
3106  *
3107  *    Functionality: Deallocating memory for function BuildSRBSetup
3108  *
3109  * @params[in] SRBs_ToBeSetup_List_t *srbSet
3110  *
3111  * @return void
3112  *
3113  *
3114  * ******************************************************************/
3115 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
3116 {
3117    uint8_t srbidx;
3118    if(srbSet->list.array != NULLP)
3119    {
3120       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
3121       {
3122          if(srbSet->list.array[srbidx]!=NULLP)
3123          {
3124             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
3125          }
3126       }
3127       CU_FREE(srbSet->list.array,srbSet->list.size);
3128    }
3129 }
3130 /*******************************************************************
3131  *
3132  * @brief Deallocating memory of function BuildAndSendUESetReq
3133  *
3134  * @details
3135  *
3136  *    Function : FreeQOSInfo
3137  *
3138  *    Functionality:  Deallocating memory for function BuildQOSInfo
3139  *
3140  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
3141  *
3142  * @return void
3143  *
3144  * ****************************************************************/
3145 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
3146 {
3147    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3148    uint8_t qosCntIdx = 0;
3149
3150    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
3151    {
3152       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3153       {
3154          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3155          {
3156             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3157                   sizeof(MaxDataBurstVolume_t));
3158          }
3159          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3160                sizeof(AveragingWindow_t));
3161       }
3162       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3163             sizeof(NonDynamic5QIDescriptor_t));
3164    }
3165    if(drbQos->iE_Extensions)
3166    {
3167       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
3168       if(qosIeExt->list.array != NULLP)
3169       {
3170          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
3171          {
3172             if(qosIeExt->list.array[qosCntIdx])
3173             {
3174                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3175             }
3176          }
3177          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3178       }
3179
3180       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3181    }
3182 }
3183 /*******************************************************************
3184  *
3185  * @brief Deallocating memory of function BuildAndSendUESetReq
3186  *
3187  * @details
3188  *
3189  *    Function : FreeULTnlInfo
3190  *
3191  *    Functionality:  Deallocating memory for function BuildULTnlInfo
3192  *
3193  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
3194  *
3195  * @return void
3196  *
3197
3198  * ****************************************************************/
3199 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
3200 {
3201    uint8_t ulidx=0;
3202    if(ulInfo->list.array != NULLP)
3203    {
3204       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
3205       {
3206          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3207          {
3208             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3209             {
3210                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3211                      transportLayerAddress.buf != NULLP)
3212                {
3213                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3214                         !=NULLP)
3215                   {
3216                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3217                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3218                            gTPTunnel->gTP_TEID.size);
3219                   }
3220                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3221                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3222                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3223                }
3224                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3225                      sizeof(GTPTunnel_t));
3226             }
3227          }
3228          if(ulInfo->list.array[ulidx]!=NULLP)
3229          {
3230             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3231          }
3232       }
3233       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3234    }
3235 }
3236 /*******************************************************************
3237  *
3238  * @brief Deallocating memory for BuildAndSendUESetReq
3239  *
3240  * @details
3241  *
3242  *    Function : FreeDRBSetup
3243  *
3244  *    Functionality:  Deallocating memory for BuildDRBSetup
3245  *
3246  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3247  *
3248  * @return void
3249  *
3250  * ****************************************************************/
3251 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3252 {
3253    DRBs_ToBeSetup_Item_t *drbSetItem;
3254    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3255
3256    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3257
3258    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3259    if(drbSet->list.array != NULLP)
3260    {
3261       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3262       {
3263               if(drbSet->list.array[drbidx] != NULLP)
3264               {
3265                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3266                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3267                  {
3268                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3269                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3270                {
3271                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3272                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3273                             {
3274                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3275                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3276                                {
3277                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3278                                        {
3279                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3280                                           {
3281                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3282                                              {
3283                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3284                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3285                                                      {
3286                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3287                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3288                                                          {
3289                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3290                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3291                                                              {
3292                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3293                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3294                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3295                                                                      {
3296                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3297                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3298                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3299                                                                          {
3300                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3301                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3302                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3303                                                                                   {
3304                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3305                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3306
3307                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3308                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3309                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3310                                                                                                    sizeof(MaxDataBurstVolume_t));
3311                                                                                   }
3312                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3313                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3314                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3315                                                                          }
3316                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3317                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3318                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3319                                                                      }
3320                                                             }
3321                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3322                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3323                                                             {
3324                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3325                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3326                                                             }
3327                                                         }
3328                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3329                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3330                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3331                                                      }
3332                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3333                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3334                                             }
3335                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3336                                                               sizeof(OCTET_STRING_t));
3337                                        }
3338                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3339                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3340                                     }
3341                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3342                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3343                             }
3344                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3345                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3346                          }
3347                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3348                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3349              }
3350              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3351                         iE_Extensions != NULLP)
3352              {
3353                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3354                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3355                  if(qosIeExt->list.array != NULLP)
3356                  {
3357                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3358                    {
3359                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3360                       {
3361                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3362                       }
3363                     }
3364                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3365                   }
3366                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3367                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3368               }
3369
3370                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3371                 }
3372                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3373               }
3374       }
3375       CU_FREE(drbSet->list.array,drbSet->list.size);
3376    }
3377 }
3378
3379
3380 /*******************************************************************
3381  *
3382  * @brief Free the UE Setup Request
3383  *
3384  * @details
3385  *
3386  *    Function : FreeUeContextSetupReq
3387  *
3388  *    Functionality: Deallocate the memory of BuildUESetReq
3389  *
3390  * @params[in]  F1AP_PDU_t  *f1apMsg
3391  *
3392  * @return void
3393  *
3394  *
3395  * ****************************************************************/
3396 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3397 {
3398    uint8_t idx, ieId;
3399    UEContextSetupRequest_t  *ueSetReq = NULLP;
3400
3401    if(f1apMsg != NULLP)
3402    {
3403       if(f1apMsg->choice.initiatingMessage != NULLP)
3404       {
3405          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3406          if(ueSetReq->protocolIEs.list.array != NULLP)
3407          {
3408             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3409             {
3410                if(ueSetReq->protocolIEs.list.array[idx])
3411                {
3412                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3413                   {
3414                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3415                         break;
3416                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3417                         break;
3418                      case ProtocolIE_ID_id_SpCell_ID:
3419                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3420                         break;
3421                      case ProtocolIE_ID_id_ServCellIndex:
3422                         break;
3423                      case ProtocolIE_ID_id_SpCellULConfigured:
3424                         break;
3425                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3426                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3427                         break;
3428                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3429                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3430                         break;
3431                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3432                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3433                         break;
3434                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3435                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3436                         break;
3437                      case ProtocolIE_ID_id_RRCContainer:
3438                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3439                         {
3440                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3441                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3442                         }
3443                         break;
3444                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3445                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3446                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3447                         break;
3448                      default:
3449                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3450                         break;
3451                   }
3452                }
3453                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3454             }
3455             for(ieId=0; ieId<idx; ieId++)
3456             {
3457                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3458                {
3459                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3460                }
3461             }
3462             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3463          }
3464          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3465       }
3466       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3467    }
3468 }
3469
3470 /**Filling cell group info **/
3471 /*******************************************************************
3472  *
3473  * @brief Build Control resource set to add/modify list
3474  *
3475  * @details
3476  *
3477  *    Function : BuildControlRSetToAddModList
3478  *
3479  *    Functionality: Build Control resource set to add/modify list
3480  *
3481  * @params[in]
3482  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3483  *
3484  * @return ROK     - success
3485  *         RFAILED - failure
3486  *
3487  * ****************************************************************/
3488    uint8_t BuildControlRSetToAddModList
3489 (
3490  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3491  )
3492 {
3493    uint8_t idx;
3494    uint8_t elementCnt;
3495    uint8_t numBytes, bitsUnused;
3496    struct ControlResourceSet *controlRSet;
3497    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3498    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3499
3500    elementCnt = 1;
3501    controlRSetList->list.count = elementCnt;
3502    controlRSetList->list.size = \
3503                                 elementCnt * sizeof(struct ControlResourceSet *);
3504
3505    controlRSetList->list.array = NULLP;
3506    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3507    if(!controlRSetList->list.array)
3508    {
3509       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3510       return RFAILED;
3511    }
3512
3513    for(idx = 0; idx < elementCnt; idx++)
3514    {
3515       controlRSetList->list.array[idx] = NULLP;
3516       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3517       if(!controlRSetList->list.array[idx])
3518       {
3519          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3520          return RFAILED;
3521       }
3522    }
3523
3524    idx=0;
3525    controlRSet = controlRSetList->list.array[idx];
3526    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3527
3528    /* Values harcoded according to our design:
3529     * size 6 bytes
3530     * 3 LSBs unsued
3531     * Bit string stored ff0000000000
3532     */
3533    numBytes = 6;
3534    bitsUnused = 3;
3535    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3536    controlRSet->frequencyDomainResources.buf = NULLP;
3537    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3538          controlRSet->frequencyDomainResources.size);
3539    if(!controlRSet->frequencyDomainResources.buf)
3540    {
3541       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3542       return RFAILED;
3543    }
3544
3545    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3546    coreset0EndPrb = CORESET0_END_PRB;
3547    coreset1StartPrb = coreset0EndPrb + 6;
3548    coreset1NumPrb = CORESET1_NUM_PRB;
3549    /* calculate the PRBs */
3550    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3551    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3552    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3553
3554    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3555    controlRSet->cce_REG_MappingType.present = \
3556                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3557
3558    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3559    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3560    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3561    controlRSet->tci_PresentInDCI = NULLP;
3562 #if 0
3563    uint8_t tciStateIdx;
3564
3565    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3566          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3567    if(!controlRset->tci_StatesPDCCH_ToAddList)
3568    {
3569       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3570       return RFAILED;
3571    }
3572
3573    elementCnt = 1;
3574    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3575    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3576    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3577          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3578       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3579       {
3580          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3581          return RFAILED;
3582       }
3583
3584    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3585    {
3586       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3587       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3588       {
3589          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3590          return RFAILED;
3591       }
3592    }
3593
3594    tciStateIdx = 0;
3595    /* TODO */
3596    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3597
3598    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3599    if(!controlRset->tci_PresentInDCI)
3600    {
3601       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3602       return RFAILED;
3603    }
3604    /* TODO */
3605    *(controlRset->tci_PresentInDCI);
3606 #endif
3607
3608    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3609    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3610    if(!controlRSet->pdcch_DMRS_ScramblingID)
3611    {
3612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3613       return RFAILED;
3614    }
3615    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3616
3617    return ROK;
3618 } /* End BuildControlRSetToAddModList */
3619
3620 /*******************************************************************
3621  *
3622  * @brief Build search space to add/modify list
3623  *
3624  * @details
3625  *
3626  *    Function : BuildSearchSpcToAddModList
3627  *
3628  *    Functionality: Build search space to add/modify list
3629  *
3630  * @params[in]
3631  * @return ROK     - success
3632  *         RFAILED - failure
3633  *
3634  * ****************************************************************/
3635    uint8_t BuildSearchSpcToAddModList
3636 (
3637  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3638  )
3639 {
3640    uint8_t idx;
3641    uint8_t numBytes;
3642    uint8_t byteIdx;
3643    uint8_t bitsUnused;
3644    uint8_t elementCnt;
3645    struct SearchSpace *searchSpc;
3646
3647    elementCnt = 1;
3648    searchSpcList->list.count = elementCnt;
3649    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3650
3651    searchSpcList->list.array = NULLP;
3652    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3653    if(!searchSpcList->list.array)
3654    {
3655       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3656       return RFAILED;
3657    }
3658
3659    for(idx = 0; idx < elementCnt; idx++)
3660    {
3661       searchSpcList->list.array[idx] = NULLP;
3662       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3663       if(!searchSpcList->list.array[idx])
3664       {
3665          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3666          return RFAILED;
3667       }
3668    }
3669
3670    idx = 0;
3671    searchSpc = searchSpcList->list.array[idx];
3672
3673    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3674
3675    searchSpc->controlResourceSetId = NULLP;
3676    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3677    if(!searchSpc->controlResourceSetId)
3678    {
3679       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3680       return RFAILED;
3681    }
3682    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3683
3684    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3685    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3686          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3687    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3688    {
3689       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3690       return RFAILED;
3691    }
3692    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3693                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3694
3695    searchSpc->duration = NULLP;
3696    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3697    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3698    if(!searchSpc->monitoringSymbolsWithinSlot)
3699    {
3700       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3701       return RFAILED;
3702    }
3703
3704    /* Values taken from reference logs :
3705     * size 2 bytes
3706     * 2 LSBs unsued
3707     * Bit string stores 8000
3708     */
3709    numBytes = 2;
3710    bitsUnused = 2;
3711
3712    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3713    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3714    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3715          searchSpc->monitoringSymbolsWithinSlot->size);
3716    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3717    {
3718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3719       return RFAILED;
3720    }
3721
3722    byteIdx = 0;
3723    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3724                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3725    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3726    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3727
3728    searchSpc->nrofCandidates = NULLP;
3729    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3730    if(!searchSpc->nrofCandidates)
3731    {
3732       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3733       return RFAILED;
3734    }
3735
3736    searchSpc->nrofCandidates->aggregationLevel1 = \
3737                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3738    searchSpc->nrofCandidates->aggregationLevel2 = \
3739                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3740    searchSpc->nrofCandidates->aggregationLevel4 = \
3741                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3742    searchSpc->nrofCandidates->aggregationLevel8 = \
3743                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3744    searchSpc->nrofCandidates->aggregationLevel16 = \
3745                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3746
3747    searchSpc->searchSpaceType = NULLP;
3748    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3749    if(!searchSpc->searchSpaceType)
3750    {
3751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3752       return RFAILED;
3753    }
3754
3755    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3756
3757    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3758    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3759          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3760    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3761    {
3762       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3763       return RFAILED;
3764    }
3765    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3766                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3767
3768    return ROK;
3769 }/* End BuildSearchSpcToAddModList */
3770
3771 /*******************************************************************
3772  *
3773  * @brief Builds BWP DL dedicated PDCCH config
3774  *
3775  * @details
3776  *
3777  *    Function : BuildBWPDlDedPdcchCfg
3778  *
3779  *    Functionality: Builds BWP DL dedicated PDCCH config
3780  *
3781  * @params[in] struct PDCCH_Config *pdcchCfg
3782  *
3783  * @return ROK     - success
3784  *         RFAILED - failure
3785  *
3786  * ****************************************************************/
3787 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3788 {
3789    pdcchCfg->controlResourceSetToAddModList = NULLP;
3790    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3791          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3792    if(!pdcchCfg->controlResourceSetToAddModList)
3793    {
3794       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3795       return RFAILED;
3796    }
3797
3798    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3799    {
3800       return RFAILED;
3801    }
3802
3803    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3804
3805    pdcchCfg->searchSpacesToAddModList = NULLP;
3806    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3807          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3808    if(!pdcchCfg->searchSpacesToAddModList)
3809    {
3810       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3811       return RFAILED;
3812    }
3813
3814    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3815    {
3816       return RFAILED;
3817    }
3818
3819    pdcchCfg->searchSpacesToReleaseList = NULLP;
3820    pdcchCfg->downlinkPreemption = NULLP;
3821    pdcchCfg->tpc_PUSCH = NULLP;
3822    pdcchCfg->tpc_PUCCH = NULLP;
3823    pdcchCfg->tpc_SRS = NULLP;
3824
3825    return ROK;
3826 }
3827
3828 /*******************************************************************
3829  *
3830  * @brief Builds DMRS DL PDSCH Mapping type A
3831  *
3832  * @details
3833  *
3834  *    Function : BuildDMRSDLPdschMapTypeA
3835  *
3836  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3837  *
3838  * @params[in]
3839  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3840  * @return ROK     - success
3841  *         RFAILED - failure
3842  *
3843  * ****************************************************************/
3844    uint8_t BuildDMRSDLPdschMapTypeA
3845 (
3846  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3847  )
3848 {
3849    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3850    dmrsDlCfg->choice.setup = NULLP;
3851    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3852    if(!dmrsDlCfg->choice.setup)
3853    {
3854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3855       return RFAILED;
3856    }
3857
3858    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3859    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3860    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3861    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3862    {
3863       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3864       return RFAILED;
3865    }
3866    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3867
3868    dmrsDlCfg->choice.setup->maxLength = NULLP;
3869    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3870    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3871    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3872
3873    return ROK;
3874 }
3875
3876 /*******************************************************************
3877  *
3878  * @brief Builds TCI states to add/modify list
3879  *
3880  * @details
3881  *
3882  *    Function : BuildTCIStatesToAddModList
3883  *
3884  *    Functionality:Builds TCI states to add/modify list
3885  *
3886  * @params[in]
3887  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3888  *
3889  * @return ROK     - success
3890  *         RFAILED - failure
3891  *
3892  * ****************************************************************/
3893 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3894 {
3895    return ROK;
3896 }
3897
3898 /*******************************************************************
3899  *
3900  * @brief Builds PDSCH time domain allocation list
3901  *
3902  * @details
3903  *
3904  *    Function : BuildPdschTimeDomAllocList
3905  *
3906  *    Functionality: Builds PDSCH time domain allocation list
3907  *
3908  * @params[in]
3909  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3910  *
3911  * @return ROK     - success
3912  *         RFAILED - failure
3913  *
3914  * ****************************************************************/
3915    uint8_t BuildPdschTimeDomAllocList
3916 (
3917  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3918  )
3919 {
3920    uint8_t idx;
3921    uint8_t elementCnt;
3922    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3923
3924    timeDomAllocList->present = \
3925                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3926
3927    timeDomAllocList->choice.setup = NULLP;
3928    CU_ALLOC(timeDomAllocList->choice.setup, \
3929          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3930    if(!timeDomAllocList->choice.setup)
3931    {
3932       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3933       return RFAILED;
3934    }
3935
3936    elementCnt = 2;
3937    timeDomAllocList->choice.setup->list.count = elementCnt;
3938    timeDomAllocList->choice.setup->list.size = \
3939                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3940
3941    timeDomAllocList->choice.setup->list.array = NULLP;
3942    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3943          timeDomAllocList->choice.setup->list.size);
3944    if(!timeDomAllocList->choice.setup->list.array)
3945    {
3946       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3947       return RFAILED;
3948    }
3949
3950    for(idx = 0; idx < elementCnt; idx++)
3951    {
3952       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3953       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3954             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3955       if(!timeDomAllocList->choice.setup->list.array[idx])
3956       {
3957          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3958          return RFAILED;
3959       }
3960    }
3961
3962    idx = 0;
3963    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3964    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3965    if(!timeDomAlloc->k0)
3966    {
3967        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3968        return RFAILED;
3969    }
3970    *(timeDomAlloc->k0) = 0;
3971    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3972    timeDomAlloc->startSymbolAndLength = 66;
3973
3974    idx++;
3975    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3976    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3977    if(!timeDomAlloc->k0)
3978    {
3979       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3980       return RFAILED;
3981    }
3982    *(timeDomAlloc->k0) = 1;
3983    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3984    timeDomAlloc->startSymbolAndLength = 66;
3985
3986    return ROK;
3987 }
3988
3989 /*******************************************************************
3990  *
3991  * @brief Builds PDSCH PRB Bundling type
3992  *
3993  * @details
3994  *
3995  *    Function : BuildPdschPrbBundlingType
3996  *
3997  *    Functionality: Builds PDSCH PRB Bundling type
3998  *
3999  * @params[in]
4000  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4001  *
4002  * @return ROK     - success
4003  *         RFAILED - failure
4004  *
4005  * ****************************************************************/
4006    uint8_t BuildPdschPrbBundlingType
4007 (
4008  struct PDSCH_Config__prb_BundlingType *prbBndlType
4009  )
4010 {
4011    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4012
4013    prbBndlType->choice.staticBundling = NULLP;
4014    CU_ALLOC(prbBndlType->choice.staticBundling, \
4015          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4016    if(!prbBndlType->choice.staticBundling)
4017    {
4018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4019       return RFAILED;
4020    }
4021    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4022
4023    return ROK;
4024 }
4025
4026 /*******************************************************************
4027  *
4028  * @brief Builds BWP DL dedicated PDSCH config
4029  *
4030  * @details
4031  *
4032  *    Function : BuildBWPDlDedPdschCfg
4033  *
4034  *    Functionality: Builds BWP DL dedicated PDSCH config
4035  *
4036  * @params[in] struct PDSCH_Config *pdschCfg
4037  *
4038  * @return ROK     - success
4039  *         RFAILED - failure
4040  *
4041  * ****************************************************************/
4042 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4043 {
4044    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4045
4046    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4047    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4048          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4049    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4050    {
4051       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4052       return RFAILED;
4053    }
4054
4055    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4056    {
4057       return RFAILED;
4058    }
4059
4060    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4061    pdschCfg->tci_StatesToAddModList = NULLP;
4062    pdschCfg->tci_StatesToReleaseList = NULLP;
4063    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4064 #if 0
4065    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4066    if(!pdschCfg->tci_StatesToAddModList)
4067    {
4068       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4069       return RFAILED;
4070    }
4071    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4072    {
4073       return RFAILED;
4074    }
4075 #endif
4076
4077    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4078
4079    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4080    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4081          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4082    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4083    {
4084       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4085       return RFAILED;
4086    }
4087    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4088    {
4089       return RFAILED;
4090    }
4091    pdschCfg->pdsch_AggregationFactor = NULLP;
4092    pdschCfg->rateMatchPatternToAddModList = NULLP;
4093    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4094    pdschCfg->rateMatchPatternGroup1 = NULLP;
4095    pdschCfg->rateMatchPatternGroup2 = NULLP;
4096    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4097    pdschCfg->mcs_Table = NULLP;
4098
4099    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4100    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4101    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4102    {
4103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4104       return RFAILED;
4105    }
4106    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4107
4108    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4109    {
4110       return RFAILED;
4111    }
4112
4113    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4114    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4115    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4116    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4117    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4118    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4119    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4120
4121    return ROK;
4122 }
4123
4124 /*******************************************************************
4125  *
4126  * @brief Builds intitial DL BWP
4127  * @details
4128  *
4129  *    Function : BuildInitialDlBWP
4130  *
4131  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4132  *
4133  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4134  *
4135  * @return ROK     - success
4136  *         RFAILED - failure
4137  *
4138  * ****************************************************************/
4139 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4140 {
4141    dlBwp->pdcch_Config = NULLP;
4142    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4143    if(!dlBwp->pdcch_Config)
4144    {
4145       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4146       return RFAILED;
4147    }
4148    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4149
4150    dlBwp->pdcch_Config->choice.setup = NULLP;
4151    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4152    if(!dlBwp->pdcch_Config->choice.setup)
4153    {
4154       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4155       return RFAILED;
4156    }
4157    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4158    {
4159       return RFAILED;
4160    }
4161
4162    dlBwp->pdsch_Config = NULLP;
4163    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4164    if(!dlBwp->pdsch_Config)
4165    {
4166       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4167       return RFAILED;
4168    }
4169    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4170
4171    dlBwp->pdsch_Config->choice.setup = NULLP;
4172    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4173    if(!dlBwp->pdsch_Config->choice.setup)
4174    {
4175       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4176       return RFAILED;
4177    }
4178
4179    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4180    {
4181       return RFAILED;
4182    }
4183
4184    dlBwp->sps_Config = NULLP;
4185    dlBwp->radioLinkMonitoringConfig = NULLP;
4186    return ROK;
4187 }
4188
4189 /*******************************************************************
4190  *
4191  * @brief Builds DMRS UL Pusch Mapping type A
4192  *
4193  * @details
4194  *
4195  *    Function : BuildDMRSULPuschMapTypeA
4196  *
4197  *    Functionality: Builds DMRS UL Pusch Mapping type A
4198  *
4199  * @params[in]
4200  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4201  * @return ROK     - success
4202  *         RFAILED - failure
4203  *
4204  * ****************************************************************/
4205    uint8_t BuildDMRSULPuschMapTypeA
4206 (
4207  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4208  )
4209 {
4210    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4211    dmrsUlCfg->choice.setup= NULLP;
4212    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4213    if(!dmrsUlCfg->choice.setup)
4214    {
4215       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4216       return RFAILED;
4217    }
4218
4219    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4220    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4221    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4222    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4223    {
4224       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4225       return RFAILED;
4226    }
4227    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4228
4229    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4230    dmrsUlCfg->choice.setup->maxLength = NULLP;
4231    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4232    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4233          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4234    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4235    {
4236       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4237       return RFAILED;
4238    }
4239
4240    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4241    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4242          sizeof(long));
4243    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4244    {
4245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4246       return RFAILED;
4247    }
4248    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4249
4250    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4251    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4252    return ROK;
4253 }
4254
4255 /*******************************************************************
4256  *
4257  * @brief Build PUSCH time domain allocation list
4258  *
4259  * @details
4260  *
4261  *    Function : BuildPuschTimeDomAllocList
4262  *
4263  *    Functionality: Build PUSCH time domain allocation list
4264  *
4265  * @params[in]
4266  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4267  *
4268  * @return ROK     - success
4269  *         RFAILED - failure
4270  *
4271  * ****************************************************************/
4272    uint8_t BuildPuschTimeDomAllocList
4273 (
4274  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4275  )
4276 {
4277    uint8_t idx;
4278    uint8_t elementCnt;
4279    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4280
4281    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4282    timeDomAllocList->choice.setup = NULLP;
4283    CU_ALLOC(timeDomAllocList->choice.setup, \
4284          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4285    if(!timeDomAllocList->choice.setup)
4286    {
4287       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4288       return RFAILED;
4289    }
4290
4291    elementCnt = 2;
4292    timeDomAllocList->choice.setup->list.count = elementCnt;
4293    timeDomAllocList->choice.setup->list.size = \
4294                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4295    timeDomAllocList->choice.setup->list.array = NULLP;
4296    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4297          timeDomAllocList->choice.setup->list.size);
4298    if(!timeDomAllocList->choice.setup->list.array)
4299    {
4300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4301       return RFAILED;
4302    }
4303
4304    for(idx = 0; idx < elementCnt; idx++)
4305    {
4306       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4307       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4308             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4309       if(!timeDomAllocList->choice.setup->list.array[idx])
4310       {
4311          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4312          return RFAILED;
4313       }
4314    }
4315
4316    idx = 0;
4317    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4318    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4319    if(!timeDomAlloc->k2)
4320    {
4321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4322       return RFAILED;
4323    }
4324    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4325    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4326    timeDomAlloc->startSymbolAndLength = 66;
4327
4328    idx++;
4329    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4330    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4331    if(!timeDomAlloc->k2)
4332    {
4333        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4334        return RFAILED;
4335    }
4336    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4337    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4338    timeDomAlloc->startSymbolAndLength = 66;
4339
4340    return ROK;
4341 }
4342
4343 /*******************************************************************
4344  *
4345  * @brief Builds BWP UL dedicated PUSCH Config
4346  *
4347  * @details
4348  *
4349  *    Function : BuildBWPUlDedPuschCfg
4350  *
4351  *    Functionality:
4352  *      Builds BWP UL dedicated PUSCH Config
4353  *
4354  * @params[in] : PUSCH_Config_t *puschCfg
4355  *
4356  * @return ROK     - success
4357  *         RFAILED - failure
4358  *
4359  * ****************************************************************/
4360 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4361 {
4362    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4363    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4364    if(!puschCfg->dataScramblingIdentityPUSCH)
4365    {
4366       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4367       return RFAILED;
4368    }
4369    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4370
4371    puschCfg->txConfig = NULLP;
4372    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4373    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4374          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4375    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4376    {
4377       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4378       return RFAILED;
4379    }
4380
4381    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4382    {
4383       return RFAILED;
4384    }
4385
4386    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4387    puschCfg->pusch_PowerControl = NULLP;
4388    puschCfg->frequencyHopping = NULLP;
4389    puschCfg->frequencyHoppingOffsetLists = NULLP;
4390    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4391
4392    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4393    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4394          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4395    if(!puschCfg->pusch_TimeDomainAllocationList)
4396    {
4397       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4398       return RFAILED;
4399    }
4400
4401    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4402    {
4403       return RFAILED;
4404    }
4405
4406    puschCfg->pusch_AggregationFactor = NULLP;
4407    puschCfg->mcs_Table = NULLP;
4408    puschCfg->mcs_TableTransformPrecoder = NULLP;
4409    puschCfg->transformPrecoder = NULLP;
4410    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4411    if(!puschCfg->transformPrecoder)
4412    {
4413       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4414       return RFAILED;
4415    }
4416    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4417
4418    puschCfg->codebookSubset = NULLP;
4419    puschCfg->maxRank = NULLP;
4420    puschCfg->rbg_Size = NULLP;
4421    puschCfg->uci_OnPUSCH = NULLP;
4422    puschCfg->tp_pi2BPSK = NULLP;
4423
4424    return ROK;
4425 }
4426
4427 /*******************************************************************
4428  *
4429  * @brief Builds BWP UL dedicated PUCCH Config
4430  *
4431  * @details
4432  *
4433  *    Function : BuildBWPUlDedPucchCfg
4434  *
4435  *    Functionality:
4436  *      Builds BWP UL dedicated PUCCH Config
4437  *
4438  * @params[in] : PUCCH_Config_t *pucchCfg
4439  *
4440  * @return ROK     - success
4441  *         RFAILED - failure
4442  *
4443  * ****************************************************************/
4444 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4445 {
4446    uint8_t arrIdx, elementCnt;
4447    uint8_t rsrcIdx, rsrcSetIdx;
4448    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4449    PUCCH_Resource_t *rsrc = NULLP;
4450
4451    //RESOURCE SET
4452    elementCnt = 1;
4453    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4454    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4455    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4456    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4457    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4458    {
4459       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4460    }
4461    rsrcSetIdx = 0;
4462    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4463    rsrcSet->pucch_ResourceSetId = 1;
4464    elementCnt = 1;
4465    rsrcSet->resourceList.list.count = elementCnt;
4466    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4467    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4468    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4469    {
4470       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4471    }
4472    rsrcIdx = 0;
4473    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4474
4475    //RESOURCE
4476    elementCnt = 1;
4477    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4478    pucchCfg->resourceToAddModList->list.count = elementCnt;
4479    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4480    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4481    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4482    {
4483       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4484    }
4485    rsrcIdx = 0;
4486    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4487    rsrc->pucch_ResourceId = 1;
4488    rsrc->startingPRB = 0;
4489    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4490    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4491    rsrc->format.choice.format1->initialCyclicShift = 0;
4492    rsrc->format.choice.format1->nrofSymbols = 4;
4493    rsrc->format.choice.format1->startingSymbolIndex = 0;
4494    rsrc->format.choice.format1->timeDomainOCC = 0;
4495
4496    //PUCCH Format 1
4497    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4498    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4499    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4500    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4501    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4502
4503    //DL DATA TO UL ACK
4504    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4505    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4506    {
4507       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4508       return RFAILED;
4509    }
4510
4511    elementCnt = 2;
4512    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4513    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4514    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4515    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4516    {
4517       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4518       return RFAILED;
4519    }
4520
4521    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4522    {
4523       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4524       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4525       {
4526           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4527           return RFAILED;
4528       }
4529    }
4530
4531    arrIdx = 0;
4532    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4533    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4534
4535    return ROK;
4536 }
4537
4538 /*******************************************************************
4539  *
4540  * @brief Fills SRS resource to add/modify list
4541  *
4542  * @details
4543  *
4544  *    Function : BuildSrsRsrcAddModList
4545  *
4546  *    Functionality: Fills SRS resource to add/modify list
4547  *
4548  * @params[in]
4549  * @return ROK     - success
4550  *         RFAILED - failure
4551  *
4552  * ****************************************************************/
4553 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4554 {
4555    uint8_t   elementCnt;
4556    uint8_t   rsrcIdx;
4557
4558    elementCnt = 1;
4559    resourceList->list.count = elementCnt;
4560    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4561    resourceList->list.array = NULLP;
4562    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4563    if(!resourceList->list.array)
4564    {
4565       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4566       return RFAILED;
4567    }
4568
4569    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4570    {
4571       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4572       if(!resourceList->list.array[rsrcIdx])
4573       {
4574          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4575          return RFAILED;
4576       }
4577    }
4578
4579    rsrcIdx = 0;
4580    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4581    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4582    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4583
4584    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4585    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4586          sizeof(struct SRS_Resource__transmissionComb__n2));
4587    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4588    {
4589       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4590       return RFAILED;
4591    }
4592    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4593       = SRS_COMB_OFFSET_N2;
4594    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4595       = SRS_CYCLIC_SHIFT_N2;
4596
4597    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4598    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4599                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4600    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4601                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4602
4603    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4604    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4605    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4606    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4607    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4608    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4609                                                                SRS_Resource__groupOrSequenceHopping_neither;
4610
4611    /* Setting resource type to aperiodic for intergration purposes */
4612    resourceList->list.array[rsrcIdx]->resourceType.present = \
4613                                                              SRS_Resource__resourceType_PR_aperiodic;
4614    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4615    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4616          sizeof(struct SRS_Resource__resourceType__aperiodic));
4617    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4618    {
4619       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4620       return RFAILED;
4621    }
4622    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4623
4624    return ROK;
4625 }
4626
4627 /*******************************************************************
4628  *
4629  * @brief Build SRS resource set Add/mod list
4630  *
4631  * @details
4632  *
4633  *    Function : BuildSrsRsrcSetAddModList
4634  *
4635  *    Functionality: Build SRS resource set Add/mod list
4636  *
4637  * @params[in]
4638  * @return ROK     - success
4639  *         RFAILED - failure
4640  *
4641  * ****************************************************************/
4642    uint8_t BuildSrsRsrcSetAddModList
4643 (
4644  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4645  )
4646 {
4647    uint8_t  elementCnt;
4648    uint8_t  rSetIdx;
4649    uint8_t  rsrcIdx;
4650    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4651
4652    elementCnt = 1;
4653    rsrcSetList->list.count = elementCnt;
4654    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4655    rsrcSetList->list.array = NULLP;
4656    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4657    if(!rsrcSetList->list.array)
4658    {
4659       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4660       return RFAILED;
4661    }
4662
4663    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4664    {
4665       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4666       if(!rsrcSetList->list.array[rSetIdx])
4667       {
4668          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4669          return RFAILED;
4670       }
4671    }
4672
4673    rSetIdx = 0;
4674    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4675
4676    /* Fill Resource Id list in resource set */
4677    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4678    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4679          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4680    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4681    {
4682       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4683       return RFAILED;
4684    }
4685
4686    elementCnt = 1;
4687    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4688    rsrcIdList->list.count = elementCnt;
4689    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4690    rsrcIdList->list.array = NULLP;
4691    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4692    if(!rsrcIdList->list.array)
4693    {
4694       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4695       return RFAILED;
4696    }
4697
4698    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4699    {
4700       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4701       if(!rsrcIdList->list.array[rsrcIdx])
4702       {
4703          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4704          return RFAILED;
4705       }
4706    }
4707
4708    rsrcIdx = 0;
4709    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4710
4711    /* Fill resource type */
4712    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4713                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4714
4715    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4716    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4717          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4718    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4719    {
4720       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4721       return RFAILED;
4722    }
4723    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4724       = APERIODIC_SRS_RESRC_TRIGGER;
4725
4726    /* TODO : Fill values for below IEs as expected by Viavi */
4727    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4728    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4729
4730
4731    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4732    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4733    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4734    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4735    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4736
4737    return ROK;
4738 }
4739
4740 /*******************************************************************
4741  *
4742  * @brief Builds BWP UL dedicated SRS Config
4743  *
4744  * @details
4745  *
4746  *    Function : BuildBWPUlDedSrsCfg
4747  *
4748  *    Functionality: Builds BWP UL dedicated SRS Config
4749  *
4750  * @params[in] SRS Config
4751  * @return ROK     - success
4752  *         RFAILED - failure
4753  *
4754  * ****************************************************************/
4755 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4756 {
4757    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4758    srsCfg->srs_ResourceSetToAddModList = NULLP;
4759    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4760          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4761    if(!srsCfg->srs_ResourceSetToAddModList)
4762    {
4763       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4764       return RFAILED;
4765    }
4766    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4767    {
4768       return RFAILED;
4769    }
4770
4771    srsCfg->srs_ResourceToReleaseList = NULLP;
4772
4773    /* Resource to Add/Modify list */
4774    srsCfg->srs_ResourceToAddModList = NULLP;
4775    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4776          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4777    if(!srsCfg->srs_ResourceToAddModList)
4778    {
4779       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4780       return RFAILED;
4781    }
4782
4783    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4784    {
4785       return RFAILED;
4786    }
4787
4788    srsCfg->tpc_Accumulation = NULLP;
4789
4790    return ROK;
4791 }
4792
4793 /*******************************************************************
4794  *
4795  * @brief Builds inital UL BWP
4796  *
4797  * @details
4798  *
4799  *    Function : BuildInitialUlBWP
4800  *
4801  *    Functionality: Builds initial UL BWP
4802  *
4803  * @params[in] BWP_UplinkDedicated_t *ulBwp
4804  * @return ROK     - success
4805  *         RFAILED - failure
4806  *
4807  * ****************************************************************/
4808 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4809 {
4810    ulBwp->pucch_Config = NULLP;
4811    ulBwp->pucch_Config = NULLP;
4812    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4813    if(!ulBwp->pucch_Config)
4814    {
4815       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4816       return RFAILED;
4817    }
4818
4819    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4820    ulBwp->pucch_Config->choice.setup = NULLP;
4821    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4822    if(!ulBwp->pucch_Config->choice.setup)
4823    {
4824       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4825       return RFAILED;
4826    }
4827
4828    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4829    {
4830       return RFAILED;
4831    }
4832
4833    /* Fill BWP UL dedicated PUSCH config */
4834    ulBwp->pusch_Config = NULLP;
4835    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4836    if(!ulBwp->pusch_Config)
4837    {
4838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4839       return RFAILED;
4840    }
4841
4842    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4843    ulBwp->pusch_Config->choice.setup = NULLP;
4844    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4845    if(!ulBwp->pusch_Config->choice.setup)
4846    {
4847       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4848       return RFAILED;
4849    }
4850
4851    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4852    {
4853       return RFAILED;
4854    }
4855
4856    ulBwp->configuredGrantConfig = NULLP;
4857
4858    /* Fill BPW UL dedicated SRS config */
4859    ulBwp->srs_Config = NULLP;
4860    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4861    if(!ulBwp->srs_Config)
4862    {
4863       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4864       return RFAILED;
4865    }
4866
4867    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4868    ulBwp->srs_Config->choice.setup = NULLP;
4869    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4870    if(!ulBwp->srs_Config->choice.setup)
4871    {
4872       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4873       return RFAILED;
4874    }
4875
4876    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4877    {
4878       return RFAILED;
4879    }
4880
4881    ulBwp->beamFailureRecoveryConfig = NULLP;
4882
4883    return ROK;
4884 }
4885
4886 /*******************************************************************
4887  *
4888  * @brief Builds Pusch Serving cell Config
4889  *
4890  * @details
4891  *
4892  *    Function : BuildPuschSrvCellCfg
4893  *
4894  *    Functionality: Builds Pusch Serving cell Config
4895  *
4896  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4897  *
4898  * @return ROK     - success
4899  *         RFAILED - failure
4900  *
4901  * ****************************************************************/
4902 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4903 {
4904    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4905    puschCfg->choice.setup = NULLP;
4906    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4907    if(!puschCfg->choice.setup)
4908    {
4909       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4910       return RFAILED;
4911    }
4912
4913    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4914    puschCfg->choice.setup->rateMatching = NULLP;
4915    puschCfg->choice.setup->xOverhead = NULLP;
4916    puschCfg->choice.setup->ext1 = NULLP;
4917    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4918    if(!puschCfg->choice.setup->ext1)
4919    {
4920       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4921       return RFAILED;
4922    }
4923
4924    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4925    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4926    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4927    {
4928       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4929       return RFAILED;
4930    }
4931    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4932
4933    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4934    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4935    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4936    {
4937       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4938       return RFAILED;
4939    }
4940    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4941    return ROK;
4942 }
4943
4944 /*******************************************************************
4945  *
4946  * @brief Builds UL config
4947  * @details
4948  *
4949  *    Function : BuildUlCfg
4950  *
4951  *    Functionality: Builds UL config in spCellCfgDed
4952  *
4953  * @params[in] UplinkConfig_t *ulCfg
4954  *
4955  * @return ROK     - success
4956  *         RFAILED - failure
4957  *
4958  * ****************************************************************/
4959 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4960 {
4961    ulCfg->initialUplinkBWP = NULLP;
4962    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4963    if(!ulCfg->initialUplinkBWP)
4964    {
4965       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4966       return RFAILED;
4967    }
4968
4969    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4970    {
4971       return RFAILED;
4972    }
4973
4974    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4975    ulCfg->uplinkBWP_ToAddModList = NULLP;
4976    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4977    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4978    if(!ulCfg->firstActiveUplinkBWP_Id)
4979    {
4980       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4981       return RFAILED;
4982    }
4983    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4984
4985    ulCfg->pusch_ServingCellConfig = NULLP;
4986    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4987          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4988    if(!ulCfg->pusch_ServingCellConfig)
4989    {
4990       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4991       return RFAILED;
4992    }
4993
4994    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4995    {
4996       return RFAILED;
4997    }
4998
4999    ulCfg->carrierSwitching = NULLP;
5000    ulCfg->ext1 = NULLP;
5001    return ROK;
5002 }
5003
5004 /*******************************************************************
5005  *
5006  * @brief Builds PDSCH serving cell config
5007  * @details
5008  *
5009  *    Function : BuildPdschSrvCellCfg
5010  *
5011  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5012  *
5013  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5014  *
5015  * @return ROK     - success
5016  *         RFAILED - failure
5017  *
5018  * ****************************************************************/
5019 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5020 {
5021    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5022    pdschCfg->choice.setup = NULLP;
5023    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5024    if(!pdschCfg->choice.setup)
5025    {
5026       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5027       return RFAILED;
5028    }
5029
5030    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5031    pdschCfg->choice.setup->xOverhead = NULLP;
5032    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5033    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5034    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5035    {
5036       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5037       return RFAILED;
5038    }
5039    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5040    pdschCfg->choice.setup->pucch_Cell = NULLP;
5041    pdschCfg->choice.setup->ext1 = NULLP;
5042
5043    return ROK;
5044 }
5045
5046 /*******************************************************************
5047  *
5048  * @brief Builds CSI Meas config
5049  * @details
5050  *
5051  *    Function : BuildCsiMeasCfg
5052  *
5053  *    Functionality: Builds CSI Meas config in spCellCfgDed
5054  *
5055  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5056  *
5057  * @return ROK     - success
5058  *         RFAILED - failure
5059  *
5060  * ****************************************************************/
5061 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5062 {
5063
5064    return ROK;
5065 }
5066
5067 /*******************************************************************
5068  *
5069  * @brief Builds Spcell config dedicated
5070  * @details
5071  *
5072  *    Function : BuildSpCellCfgDed
5073  *
5074  *    Functionality: Builds sp cell config dedicated in spCellCfg
5075  *
5076  * @params[in] ServingCellConfig_t srvCellCfg
5077  *
5078  * @return ROK     - success
5079  *         RFAILED - failure
5080  *
5081  * ****************************************************************/
5082 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5083 {
5084    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5085
5086    srvCellCfg->initialDownlinkBWP = NULLP;
5087    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5088    if(!srvCellCfg->initialDownlinkBWP)
5089    {
5090       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5091       return RFAILED;
5092    }
5093
5094    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5095    {
5096       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5097       return RFAILED;
5098    }
5099    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5100    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5101
5102    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5103    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5104    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5105    {
5106       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5107       return RFAILED;
5108    }
5109    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5110
5111    srvCellCfg->bwp_InactivityTimer = NULLP;
5112
5113    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5114    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5115    if(!srvCellCfg->defaultDownlinkBWP_Id)
5116    {
5117       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5118       return RFAILED;
5119    }
5120    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5121
5122    srvCellCfg->uplinkConfig = NULLP;
5123    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5124    if(!srvCellCfg->uplinkConfig)
5125    {
5126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5127       return RFAILED;
5128    }
5129
5130    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5131    {
5132       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5133       return RFAILED;
5134    }
5135    srvCellCfg->supplementaryUplink = NULLP;
5136    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5137
5138    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5139    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5140    if(!srvCellCfg->pdsch_ServingCellConfig)
5141    {
5142       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5143       return RFAILED;
5144    }
5145
5146    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5147    {
5148       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5149       return RFAILED;
5150    }
5151
5152    srvCellCfg->csi_MeasConfig = NULLP;
5153 #if 0
5154    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5155       if(!srvCellCfg->csi_MeasConfig)
5156       {
5157          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5158          return RFAILED;
5159       }
5160
5161    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5162    {
5163       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5164       return RFAILED;
5165    }
5166 #endif
5167    srvCellCfg->sCellDeactivationTimer = NULLP;
5168    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5169    srvCellCfg->tag_Id = TAG_ID;
5170    srvCellCfg->dummy = NULLP;
5171    srvCellCfg->pathlossReferenceLinking = NULLP;
5172    srvCellCfg->servingCellMO = NULLP;
5173    srvCellCfg->ext1 = NULLP;
5174
5175    return ROK;
5176 }
5177 /*******************************************************************
5178  *
5179  * @brief Builds Spcell config
5180  *
5181  * @details
5182  *
5183  *    Function : BuildSpCellCfg
5184  *
5185  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5186  *
5187  * @params[in] SpCellConfig_t spCellCfg
5188  *
5189  * @return ROK     - success
5190  *         RFAILED - failure
5191  *
5192  * ****************************************************************/
5193 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5194 {
5195
5196    spCellCfg->servCellIndex = NULLP;
5197    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5198    if(!spCellCfg->servCellIndex)
5199    {
5200       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5201       return RFAILED;
5202    }
5203    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5204
5205    spCellCfg->reconfigurationWithSync = NULLP;
5206    spCellCfg->rlf_TimersAndConstants = NULLP;
5207    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5208    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5209    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5210    {
5211       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5212       return RFAILED;
5213    }
5214    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5215
5216    spCellCfg->spCellConfigDedicated = NULLP;
5217    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5218    if(!spCellCfg->spCellConfigDedicated)
5219    {
5220       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5221       return RFAILED;
5222    }
5223    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5224    {
5225       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5226       return RFAILED;
5227    }
5228    return ROK;
5229 }
5230 /*******************************************************************
5231  *
5232  * @brief Builds Phy cell group config
5233  *
5234  * @details
5235  *
5236  *    Function : BuildPhyCellGrpCfg
5237  *
5238  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5239  *
5240  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5241  *
5242  * @return ROK     - success
5243  *         RFAILED - failure
5244  *
5245  * ****************************************************************/
5246 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5247 {
5248    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5249    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5250
5251    phyCellGrpCfg->p_NR_FR1 = NULLP;
5252    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5253    if(!phyCellGrpCfg->p_NR_FR1)
5254    {
5255       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5256       return RFAILED;
5257    }
5258    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5259    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5260    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5261    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5262    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5263    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5264    phyCellGrpCfg->cs_RNTI = NULLP;
5265    phyCellGrpCfg->ext1 = NULLP;
5266    phyCellGrpCfg->ext2 = NULLP;
5267
5268    return ROK;
5269 }
5270
5271 /*******************************************************************
5272  *
5273  * @brief Builds tag config
5274  *
5275  * @details
5276  *
5277  *    Function : BuildTagConfig
5278  *
5279  *    Functionality: Builds tag config in MacCellGroupConfig
5280  *
5281  * @params[in] TAG_Config *tag_Config
5282  *
5283  * @return ROK     - success
5284  *         RFAILED - failure
5285  *
5286  * ****************************************************************/
5287 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5288 {
5289    struct TAG_Config__tag_ToAddModList *tagList;
5290    uint8_t                     idx, elementCnt;
5291
5292    tagConfig->tag_ToReleaseList = NULLP;
5293    tagConfig->tag_ToAddModList = NULLP;
5294    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5295    if(!tagConfig->tag_ToAddModList)
5296    {
5297       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5298       return RFAILED;
5299    }
5300
5301    elementCnt = 1; //ODU_VALUE_ONE;
5302    tagList = tagConfig->tag_ToAddModList;
5303    tagList->list.count = elementCnt;
5304    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5305
5306    tagList->list.array = NULLP;
5307    CU_ALLOC(tagList->list.array, tagList->list.size);
5308    if(!tagList->list.array)
5309    {
5310       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5311       return RFAILED;
5312    }
5313
5314    for(idx=0; idx<tagList->list.count; idx++)
5315    {
5316       tagList->list.array[idx] = NULLP;
5317       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5318       if(!tagList->list.array[idx])
5319       {
5320          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5321          return RFAILED;
5322       }
5323    }
5324
5325    idx = 0;
5326    tagList->list.array[idx]->tag_Id = TAG_ID;
5327    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5328
5329    return ROK;
5330 }
5331
5332 /*******************************************************************
5333  *
5334  * @brief Builds PHR Config
5335  *
5336  * @details
5337  *
5338  *    Function : BuildPhrConfig
5339  *
5340  *    Functionality: Builds phrConfig in MacCellGroupConfig
5341  *
5342  * @params[in] PHR Config *
5343  *
5344  * @return ROK     - success
5345  *         RFAILED - failure
5346  *
5347  * ****************************************************************/
5348 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5349 {
5350
5351    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5352    phrConfig->choice.setup = NULLP;
5353    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5354    if(!phrConfig->choice.setup)
5355    {
5356       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5357       return RFAILED;
5358    }
5359
5360    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5361    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5362    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5363    phrConfig->choice.setup->multiplePHR              = false;
5364    phrConfig->choice.setup->dummy                    = false;
5365    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5366    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5367
5368    return ROK;
5369 }
5370
5371 /*******************************************************************
5372  *
5373  * @brief Builds BSR Config
5374  *
5375  * @details
5376  *
5377  *    Function : BuildBsrConfig
5378  *
5379  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5380  *
5381  * @params[in] BSR_Config *bsrConfig
5382  *
5383  * @return ROK     - success
5384  *         RFAILED - failure
5385  *
5386  * ****************************************************************/
5387 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5388 {
5389    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5390    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5391    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5392
5393    return ROK;
5394 }
5395
5396 /*******************************************************************
5397  *
5398  * @brief Builds scheduling request config
5399  *
5400  * @details
5401  *
5402  *    Function : BuildSchedulingReqConfig
5403  *
5404  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5405  *
5406  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5407  *
5408  * @return ROK     - success
5409  *         RFAILED - failure
5410  *
5411  * ****************************************************************/
5412 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5413 {
5414    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5415    uint8_t                     idx, elementCnt;
5416
5417    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5418    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5419          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5420    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5421    {
5422       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5423       return RFAILED;
5424    }
5425
5426    elementCnt = 1; //ODU_VALUE_ONE;
5427    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5428    schReqList->list.count = elementCnt;
5429    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5430
5431    schReqList->list.array = NULLP;
5432    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5433    if(!schReqList->list.array)
5434    {
5435       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5436       return RFAILED;
5437    }
5438
5439    for(idx=0;idx<schReqList->list.count; idx++)
5440    {
5441       schReqList->list.array[idx] = NULLP;
5442       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5443       if(!schReqList->list.array[idx])
5444       {
5445          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5446          return RFAILED;
5447       }
5448    }
5449
5450    idx = 0;
5451    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5452
5453    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5454    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5455    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5456    {
5457       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5458       return RFAILED;
5459    }
5460    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5461    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5462    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5463
5464    return ROK;
5465 }
5466 /*******************************************************************
5467  *
5468  * @brief Builds Mac cell group config
5469  *
5470  * @details
5471  *
5472  *    Function : BuildMacCellGrpCfg
5473  *
5474  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5475  *
5476  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5477  *
5478  * @return ROK     - success
5479  *         RFAILED - failure
5480  *
5481  * ****************************************************************/
5482 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5483 {
5484    macCellGrpCfg->drx_ConfigRrc = NULLP;
5485    macCellGrpCfg->schedulingRequestConfig = NULLP;
5486    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5487    if(!macCellGrpCfg->schedulingRequestConfig)
5488    {
5489       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5490       return RFAILED;
5491    }
5492
5493    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5494    {
5495       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5496       return RFAILED;
5497    }
5498
5499    macCellGrpCfg->bsr_Config = NULLP;
5500    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5501    if(!macCellGrpCfg->bsr_Config)
5502    {
5503       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5504       return RFAILED;
5505    }
5506
5507    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5508    {
5509       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5510       return RFAILED;
5511    }
5512
5513    macCellGrpCfg->tag_Config = NULLP;
5514    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5515    if(!macCellGrpCfg->tag_Config)
5516    {
5517       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5518       return RFAILED;
5519    }
5520
5521    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5522    {
5523       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5524       return RFAILED;
5525    }
5526
5527    macCellGrpCfg->phr_Config = NULLP;
5528    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5529    if(!macCellGrpCfg->phr_Config)
5530    {
5531       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5532       return RFAILED;
5533    }
5534
5535    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5536    {
5537       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5538       return RFAILED;
5539    }
5540
5541    macCellGrpCfg->skipUplinkTxDynamic = false;
5542    macCellGrpCfg->ext1 = NULLP;
5543
5544    return ROK;
5545 }
5546 /*******************************************************************
5547  *
5548  * @brief Frees memeory allocated for SearchSpcToAddModList
5549  *
5550  * @details
5551  *
5552  *    Function : FreeSearchSpcToAddModList
5553  *
5554  *    Functionality: Deallocating memory of SearchSpcToAddModList
5555  *
5556  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5557  *
5558  * @return void
5559  *
5560  4221 * ****************************************************************/
5561 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5562 {
5563    uint8_t idx1=0;
5564    uint8_t idx2=0;
5565    struct  SearchSpace *searchSpc=NULLP;
5566
5567    if(searchSpcList->list.array)
5568    {
5569       if(searchSpcList->list.array[idx2])
5570       {
5571          searchSpc = searchSpcList->list.array[idx2];
5572          if(searchSpc->controlResourceSetId)
5573          {
5574             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5575             {
5576                if(searchSpc->monitoringSymbolsWithinSlot)
5577                {
5578                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5579                   {
5580                      if(searchSpc->nrofCandidates)
5581                      {
5582                         if(searchSpc->searchSpaceType)
5583                         {
5584                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5585                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5586                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5587                                     SearchSpace__searchSpaceType));
5588                         }
5589                         CU_FREE(searchSpc->nrofCandidates,
5590                               sizeof(struct SearchSpace__nrofCandidates));
5591                      }
5592                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5593                            searchSpc->monitoringSymbolsWithinSlot->size);
5594                   }
5595                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5596                         sizeof(BIT_STRING_t));
5597                }
5598                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5599                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5600             }
5601             CU_FREE(searchSpc->controlResourceSetId,
5602                   sizeof(ControlResourceSetId_t));
5603          }
5604       }
5605       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5606       {
5607          CU_FREE(searchSpcList->list.array[idx1],
5608                sizeof(struct SearchSpace));
5609       }
5610       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5611    }
5612 }
5613 /*******************************************************************
5614  *
5615  * @brief Frees memory allocated for PdschTimeDomAllocList
5616  *
5617  * @details
5618  *
5619  *    Function : FreePdschTimeDomAllocList
5620  *
5621  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5622  *
5623  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5624  *
5625  * @return void
5626  *
5627  4221 * ****************************************************************/
5628 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5629 {
5630    uint8_t idx1=0;
5631
5632    if(timeDomAllocList->choice.setup)
5633    {
5634       if(timeDomAllocList->choice.setup->list.array)
5635       {
5636          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5637          {
5638             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5639                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5640          }
5641          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5642                timeDomAllocList->choice.setup->list.size);
5643       }
5644       CU_FREE(timeDomAllocList->choice.setup,\
5645             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5646    }
5647 }
5648 /*******************************************************************
5649  *
5650  * @brief Frees memory allocated for PuschTimeDomAllocList
5651  *
5652  *@details
5653  *
5654  *    Function : FreePuschTimeDomAllocList
5655  *
5656  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5657  *
5658  * @params[in] PUSCH_Config_t *puschCfg
5659  *
5660  * @return void
5661  *
5662  ***********************************************************************/
5663 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5664 {
5665    uint8_t idx1=0;
5666    uint8_t idx2=0;
5667    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5668
5669    if(puschCfg->pusch_TimeDomainAllocationList)
5670    {
5671       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5672       if(timeDomAllocList_t->choice.setup)
5673       {
5674          if(timeDomAllocList_t->choice.setup->list.array)
5675          {
5676             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5677             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5678             {
5679                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5680                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5681             }
5682             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5683                   timeDomAllocList_t->choice.setup->list.size);
5684          }
5685          CU_FREE(timeDomAllocList_t->choice.setup, \
5686                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5687       }
5688       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5689       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5690             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5691    }
5692
5693 }
5694
5695 /*******************************************************************
5696  *
5697  * @brief Frees memory allocated for Dedicated PUCCH config
5698  *
5699  * @details
5700  *
5701  *    Function : FreeBWPUlDedPucchCfg
5702  *
5703  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5704  *
5705  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5706  *
5707  * @return void
5708  *
5709  * ****************************************************************/
5710 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5711 {
5712    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5713    PUCCH_Config_t *pucchCfg = NULLP;
5714    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5715    PUCCH_Resource_t *rsrc = NULLP;
5716
5717    if(ulBwpPucchCfg)
5718    {
5719       if(ulBwpPucchCfg->choice.setup)
5720       {
5721          pucchCfg = ulBwpPucchCfg->choice.setup;
5722
5723          //Free resource set list
5724          if(pucchCfg->resourceSetToAddModList)
5725          {
5726             if(pucchCfg->resourceSetToAddModList->list.array)
5727             {
5728                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5729                {
5730                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5731                   if(rsrcSet->resourceList.list.array)
5732                   {
5733                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5734                      {
5735                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5736                      }
5737                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5738                   }
5739                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5740                }
5741                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5742             }
5743             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5744          }
5745
5746          //Free resource list
5747          if(pucchCfg->resourceToAddModList)
5748          {
5749             if(pucchCfg->resourceToAddModList->list.array)
5750             {
5751                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5752                {
5753                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5754                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5755                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5756                }
5757                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5758             }
5759             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5760          }
5761
5762          //PUCCH Format 1
5763          if(pucchCfg->format1)
5764          {
5765             if(pucchCfg->format1->choice.setup)
5766             {
5767                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5768                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5769             }
5770             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5771          }
5772
5773          //DL DATA TO UL ACK
5774          if(pucchCfg->dl_DataToUL_ACK)
5775          {
5776             if(pucchCfg->dl_DataToUL_ACK->list.array)
5777             {
5778                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5779                {
5780                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5781                }
5782                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5783             }
5784             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5785          }
5786
5787          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5788       }
5789       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5790    }
5791 }
5792
5793 /*******************************************************************
5794  *
5795  * @brief Frees memory allocated for InitialUlBWP
5796  *
5797  * @details
5798  *
5799  *    Function : FreeInitialUlBWP
5800  *
5801  *    Functionality: Deallocating memory of InitialUlBWP
5802  *
5803  * @params[in] BWP_UplinkDedicated_t *ulBwp
5804  *
5805  * @return void
5806  *
5807  * ****************************************************************/
5808 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5809 {
5810    uint8_t  rSetIdx, rsrcIdx;
5811    SRS_Config_t   *srsCfg = NULLP;
5812    PUSCH_Config_t *puschCfg = NULLP;
5813    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5814    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5815    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5816    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5817
5818    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5819
5820    if(ulBwp->pusch_Config)
5821    {
5822       if(ulBwp->pusch_Config->choice.setup)
5823       {
5824          puschCfg=ulBwp->pusch_Config->choice.setup;
5825          if(puschCfg->dataScramblingIdentityPUSCH)
5826          {
5827             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5828             {
5829                FreePuschTimeDomAllocList(puschCfg);
5830                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5831                if(dmrsUlCfg->choice.setup)
5832                {
5833                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5834                   {
5835                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5836                      {
5837                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5838                               sizeof(long));
5839                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5840                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5841                      }
5842                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5843                            sizeof(long));
5844                   }
5845                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5846                }
5847                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5848                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5849             }
5850             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5851          }
5852          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5853       }
5854       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5855
5856       /* Free SRS-Config */
5857       if(ulBwp->srs_Config)
5858       {
5859          if(ulBwp->srs_Config->choice.setup)
5860          {
5861             srsCfg = ulBwp->srs_Config->choice.setup;
5862
5863             /* Free Resource Set to add/mod list */
5864             if(srsCfg->srs_ResourceSetToAddModList)
5865             {
5866                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5867                if(rsrcSetList->list.array)
5868                {
5869                   rSetIdx = 0;
5870
5871                   /* Free SRS resource Id list in this SRS resource set */
5872                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5873                   {
5874                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5875
5876                      if(rsrcIdList->list.array)
5877                      {
5878                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5879                         {
5880                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5881                         }
5882                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5883                      }
5884                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5885                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5886                   }
5887
5888                   /* Free resource type info for this SRS resource set */
5889                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5890                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5891
5892                   /* Free memory for each resource set */
5893                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5894                   {
5895                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5896                   }
5897                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5898                }
5899                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5900                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5901             }
5902
5903             /* Free resource to add/modd list */
5904             if(srsCfg->srs_ResourceToAddModList)
5905             {
5906                resourceList = srsCfg->srs_ResourceToAddModList;
5907                if(resourceList->list.array)
5908                {
5909                   rsrcIdx = 0;
5910                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5911                         sizeof(struct SRS_Resource__transmissionComb__n2));
5912                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5913                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5914
5915                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5916                   {
5917                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5918                   }
5919                   CU_FREE(resourceList->list.array, resourceList->list.size);
5920                }
5921                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5922                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5923             }
5924
5925             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5926          }
5927          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5928       }
5929    }
5930 }
5931 /*******************************************************************
5932  *
5933  * @brief Frees memory allocated for initialUplinkBWP
5934  *
5935  * @details
5936  *
5937  *    Function : FreeinitialUplinkBWP
5938  *
5939  *    Functionality: Deallocating memory of initialUplinkBWP
5940  *
5941  * @params[in] UplinkConfig_t *ulCfg
5942  *
5943  * @return void
5944  *
5945  *
5946  * ****************************************************************/
5947 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5948 {
5949    BWP_UplinkDedicated_t *ulBwp=NULLP;
5950    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5951
5952    if(ulCfg->initialUplinkBWP)
5953    {
5954       ulBwp=ulCfg->initialUplinkBWP;
5955       if(ulCfg->firstActiveUplinkBWP_Id)
5956       {
5957          if(ulCfg->pusch_ServingCellConfig)
5958          {
5959             puschCfg=ulCfg->pusch_ServingCellConfig;
5960             if(puschCfg->choice.setup)
5961             {
5962                if(puschCfg->choice.setup->ext1)
5963                {
5964                   CU_FREE(puschCfg->choice.setup->ext1->\
5965                         processingType2Enabled,sizeof(BOOLEAN_t));
5966                   CU_FREE(puschCfg->choice.setup->ext1->\
5967                         maxMIMO_Layers,sizeof(long));
5968                   CU_FREE(puschCfg->choice.setup->ext1, \
5969                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5970                }
5971                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5972             }
5973             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5974          }
5975          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5976       }
5977       FreeInitialUlBWP(ulBwp);
5978       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5979    }
5980 }
5981 /*******************************************************************
5982  *
5983  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5984  *
5985  * @details
5986  *
5987  *    Function : FreeBWPDlDedPdschCfg
5988  *
5989  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5990  *
5991  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5992  *
5993  * @return void
5994  *
5995  *
5996  * ****************************************************************/
5997 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5998 {
5999    struct PDSCH_Config *pdschCfg=NULLP;
6000    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6001    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6002    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6003
6004    if(dlBwp->pdsch_Config->choice.setup)
6005    {
6006       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6007       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6008       {
6009          if(pdschCfg->pdsch_TimeDomainAllocationList)
6010          {
6011             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6012             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6013             {
6014                prbBndlType=&pdschCfg->prb_BundlingType;
6015                CU_FREE(prbBndlType->choice.staticBundling,\
6016                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6017                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6018             }
6019             FreePdschTimeDomAllocList(timeDomAllocList);
6020             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6021                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6022          }
6023          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6024          if(dmrsDlCfg->choice.setup)
6025          {
6026             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6027                   sizeof(long));
6028             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6029          }
6030          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6031                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6032       }
6033       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6034    }
6035 }
6036 /*******************************************************************
6037  *
6038  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6039  *
6040  * @details
6041  *
6042  *    Function : FreeBWPDlDedPdcchCfg
6043  *
6044  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6045  *
6046  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6047  *
6048  * @return void
6049  *
6050  *
6051  * ****************************************************************/
6052 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6053 {
6054    uint8_t idx1=0;
6055    uint8_t idx2=0;
6056    struct PDCCH_Config *pdcchCfg=NULLP;
6057    struct ControlResourceSet *controlRSet=NULLP;
6058    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6059
6060    if(dlBwp->pdcch_Config->choice.setup)
6061    {
6062       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6063       if(pdcchCfg->controlResourceSetToAddModList)
6064       {
6065          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6066          if(controlRSetList->list.array)
6067          {
6068             controlRSet = controlRSetList->list.array[idx2];
6069             if(controlRSet)
6070             {
6071                if(controlRSet->frequencyDomainResources.buf)
6072                {
6073                   if(controlRSet->pdcch_DMRS_ScramblingID)
6074                   {
6075                      if(pdcchCfg->searchSpacesToAddModList)
6076                      {
6077                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6078                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
6079                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6080                      }
6081                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6082                   }
6083                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
6084                         controlRSet->frequencyDomainResources.size);
6085                }
6086             }
6087             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6088             {
6089                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6090             }
6091             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6092          }
6093          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6094                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6095       }
6096       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6097    }
6098 }
6099 /*******************************************************************
6100  *
6101  * @brief Builds RLC Config
6102  *
6103  * @details
6104  *
6105  *    Function : BuildRlcConfig
6106  *
6107  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
6108  *
6109  * @params[in] RLC_Config *rlcConfig
6110  *
6111  * @return ROK     - success
6112  *         RFAILED - failure
6113  *
6114  * ****************************************************************/
6115 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
6116 {
6117    rlcConfig->present = rlcLcCfgDb.rlcMode;
6118
6119    switch(rlcConfig->present)
6120    {
6121       case RLC_Config_PR_am:
6122          {
6123             rlcConfig->choice.am = NULLP;
6124             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6125             if(!rlcConfig->choice.am)
6126             {
6127                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6128                return RFAILED;
6129             }
6130
6131             /* UL */
6132             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
6133             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6134             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
6135             {
6136                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6137                return RFAILED;
6138             }
6139             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
6140             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
6141             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
6142             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
6143             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
6144
6145             /* DL */
6146             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
6147             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6148             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
6149             {
6150                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6151                return RFAILED;
6152             }
6153             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
6154             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
6155             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
6156
6157             break;
6158          }
6159
6160       case RLC_Config_PR_um_Bi_Directional:
6161          {
6162             rlcConfig->choice.um_Bi_Directional = NULLP;
6163             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
6164             if(!rlcConfig->choice.um_Bi_Directional)
6165             {
6166                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6167                return RFAILED;
6168             }
6169
6170             /* UL */
6171             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
6172             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6173             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
6174             {
6175                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6176                return RFAILED;
6177             }
6178             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
6179
6180             /* DL */
6181             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
6182             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6183             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
6184             {
6185                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6186                return RFAILED;
6187             }
6188             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
6189             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
6190             break;
6191          }
6192    }
6193    return ROK;
6194 }
6195
6196 /*******************************************************************
6197  *
6198  * @brief Builds MAC LC Config
6199  *
6200  * @details
6201  *
6202  *    Function : BuildMacLCConfig
6203  *
6204  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
6205  *
6206  * @params[in] struct LogicalChannelConfig macLcConfig
6207  *
6208  * @return ROK     - success
6209  *         RFAILED - failure
6210  *
6211  * ****************************************************************/
6212 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6213 {
6214
6215    macLcConfig->ul_SpecificParameters = NULLP;
6216    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6217    if(!macLcConfig->ul_SpecificParameters)
6218    {
6219       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6220       return RFAILED;
6221    }
6222
6223    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6224    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6225    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6226    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6227    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6228    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6229    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6230
6231    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6232    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6233    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6234    {
6235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6236       return RFAILED;
6237    }
6238    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6239
6240    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6241    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6242    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6243    {
6244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6245       return RFAILED;
6246    }
6247    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6248
6249    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6250    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6251    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6252
6253    return ROK;
6254 }
6255 /*******************************************************************
6256  *
6257  * @brief Builds RLC Bearer to Add/Mod list
6258  *
6259  * @details
6260  *
6261  *    Function :BuildRlcBearerToAddModList
6262  *
6263  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6264  *
6265  * @params[in] rlc_BearerToAddModList
6266  *
6267  * @return ROK     - success
6268  *         RFAILED - failure
6269  *
6270  * ****************************************************************/
6271 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6272 {
6273    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6274
6275    if(updateAllRbCfg)
6276       elementCnt = ueCb->numSrb + ueCb->numDrb;
6277    else
6278    {
6279       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6280       {
6281          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6282             elementCnt++;
6283       }
6284
6285       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6286       {
6287          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6288             elementCnt++;
6289       }
6290    }
6291
6292    if(!elementCnt)
6293    {
6294       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6295       return ROK;
6296    }
6297    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6298    if(!rlcBearerList)
6299    {
6300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6301       return RFAILED;
6302    }
6303    rlcBearerList->list.count = elementCnt;
6304    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6305
6306    rlcBearerList->list.array = NULLP;
6307    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6308    if(!rlcBearerList->list.array)
6309    {
6310       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6311       return RFAILED;
6312    }
6313
6314    for(idx=0; idx<rlcBearerList->list.count; idx++)
6315    {
6316       rlcBearerList->list.array[idx] = NULLP;
6317       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6318       if(!rlcBearerList->list.array[idx])
6319       {
6320          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6321          return RFAILED;
6322       }
6323    }
6324
6325    idx = 0;
6326
6327    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6328    {
6329       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6330          continue;
6331
6332       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6333
6334       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6335       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6336       {
6337          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6338          return RFAILED;
6339       }
6340
6341       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6342       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6343
6344       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6345       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6346       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6347       if(!rlcBearerList->list.array[idx]->rlc_Config)
6348       {
6349          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6350          return RFAILED;
6351       }
6352
6353       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6354       {
6355          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6356          return RFAILED;
6357       }
6358
6359       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6360       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6361       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6362       {
6363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6364          return RFAILED;
6365       }
6366
6367       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6368       {
6369          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6370          return RFAILED;
6371       }
6372       idx++;
6373    }
6374
6375    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6376    {
6377       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6378          continue;
6379
6380       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6381
6382       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6383       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6384       {
6385          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6386          return RFAILED;
6387       }
6388
6389       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6390       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6391
6392       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6393       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6394       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6395       if(!rlcBearerList->list.array[idx]->rlc_Config)
6396       {
6397          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6398          return RFAILED;
6399       }
6400
6401       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6402       {
6403          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6404          return RFAILED;
6405       }
6406
6407       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6408       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6409       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6410       {
6411          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6412          return RFAILED;
6413       }
6414
6415       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6416       {
6417          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6418          return RFAILED;
6419       }
6420       idx++;
6421    }
6422    return ROK;
6423 }
6424
6425 /*******************************************************************
6426  *
6427  * @brief Free memory allocated for CellGroupConfig
6428  *
6429  * @details
6430  *
6431  *    Function : FreeMemCellGrpCfg
6432  *
6433  *    Functionality: Deallocating memory of CellGroupConfig
6434  *
6435  * @params[in] pointer to CellGroupConfigRrc_t
6436  *
6437  * @return ROK     - success
6438  *         RFAILED - failure
6439  *
6440  ******************************************************************/
6441 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6442 {
6443    uint8_t idx=0;
6444    SpCellConfig_t *spCellCfg=NULLP;
6445    ServingCellConfig_t *srvCellCfg=NULLP;
6446    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6447    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6448    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6449    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6450    struct RLC_Config *rlcConfig=NULLP;
6451    struct LogicalChannelConfig *macLcConfig=NULLP;
6452    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6453    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6454    struct TAG_Config *tagConfig=NULLP;
6455    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6456    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6457    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6458
6459    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6460    if(rlcBearerList)
6461    {
6462       if(rlcBearerList->list.array)
6463       {
6464          for(idx=0; idx<rlcBearerList->list.count; idx++)
6465          {
6466             if(rlcBearerList->list.array[idx])
6467             {
6468                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6469                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6470                if(rlcConfig)
6471                {
6472                   if(rlcConfig->choice.am)
6473                   {
6474                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6475                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6476                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6477                   }
6478                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6479                }
6480                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6481                if(macLcConfig)
6482                {
6483                   if(macLcConfig->ul_SpecificParameters)
6484                   {
6485                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6486                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6487                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6488                   }
6489                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6490                }
6491                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6492             }
6493          }
6494          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6495       }
6496       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6497    }
6498
6499    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6500    if(macCellGrpCfg)
6501    {
6502       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6503       if(schedulingRequestConfig)
6504       {
6505          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6506          if(schReqList)
6507          {
6508             if(schReqList->list.array)
6509             {
6510                for(idx=0;idx<schReqList->list.count; idx++)
6511                {
6512                   if(schReqList->list.array[idx])
6513                   {
6514                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6515                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6516                   }
6517                }
6518                CU_FREE(schReqList->list.array, schReqList->list.size);
6519             }
6520             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6521                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6522             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6523       }
6524       if(macCellGrpCfg->bsr_Config)
6525       {
6526          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6527       }
6528       tagConfig = macCellGrpCfg->tag_Config;
6529       if(tagConfig)
6530       {
6531          tagList = tagConfig->tag_ToAddModList;
6532          if(tagList)
6533          {
6534             if(tagList->list.array)
6535             {
6536                for(idx=0; idx<tagList->list.count; idx++)
6537                {
6538                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6539                }
6540                CU_FREE(tagList->list.array, tagList->list.size);
6541             }
6542             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6543          }
6544          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6545       }
6546
6547       phrConfig = macCellGrpCfg->phr_Config;
6548       if(phrConfig)
6549       {
6550          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6551          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6552       }
6553
6554       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6555    }
6556
6557    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6558    if(phyCellGrpCfg)
6559    {
6560       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6561       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6562    }
6563
6564    spCellCfg = cellGrpCfg->spCellConfig;
6565    if(spCellCfg)
6566    {
6567       if(spCellCfg->servCellIndex)
6568       {
6569          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6570          {
6571             if(spCellCfg->spCellConfigDedicated)
6572             {
6573                srvCellCfg = spCellCfg->spCellConfigDedicated;
6574                if(srvCellCfg->initialDownlinkBWP)
6575                {
6576                   dlBwp = srvCellCfg->initialDownlinkBWP;
6577                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6578                   {
6579                      if(srvCellCfg->defaultDownlinkBWP_Id)
6580                      {
6581                         if(srvCellCfg->uplinkConfig)
6582                         {
6583                            if(srvCellCfg->pdsch_ServingCellConfig)
6584                            {
6585                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6586                               if(pdschCfg->choice.setup)
6587                               {
6588                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6589                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6590                               }
6591                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6592                                        ServingCellConfig__pdsch_ServingCellConfig));
6593                            }
6594                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6595                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6596                         }
6597                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6598                      }
6599                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6600                   }
6601                   if(dlBwp->pdcch_Config)
6602                   {
6603                      if(dlBwp->pdsch_Config)
6604                      {
6605                         FreeBWPDlDedPdschCfg(dlBwp);
6606                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6607                      }
6608                      FreeBWPDlDedPdcchCfg(dlBwp);
6609                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6610                   }
6611                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6612                }
6613                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6614             }
6615             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6616          }
6617          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6618       }
6619       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6620    }
6621    return ROK;
6622 }
6623
6624 /*******************************************************************
6625  *
6626  * @brief Fills CellGroupConfig
6627  *
6628  * @details
6629  *
6630  *    Function : fillCellGrpCfg
6631  *
6632  *    Functionality: Fills CellGroupConfig
6633  *
6634  * @params[in] pointer to CellGroupConfigRrc_t
6635  *
6636  * @return ROK     - success
6637  *         RFAILED - failure
6638  *
6639  ******************************************************************/
6640
6641 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6642 {
6643    uint8_t               ret = RFAILED;
6644    CellGroupConfigRrc_t  cellGrpCfg;
6645    asn_enc_rval_t        encRetVal;
6646
6647    while(true)
6648    {
6649       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6650
6651       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6652
6653       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6654       {
6655          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6656          break;
6657       }
6658
6659       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6660       cellGrpCfg.mac_CellGroupConfig = NULLP;
6661       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6662       if(!cellGrpCfg.mac_CellGroupConfig)
6663       {
6664          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6665          break;
6666       }
6667       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6668       {
6669          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6670          break;
6671       }
6672
6673       cellGrpCfg.physicalCellGroupConfig = NULLP;
6674       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6675       if(!cellGrpCfg.physicalCellGroupConfig)
6676       {
6677          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6678          break;
6679       }
6680       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6681       {
6682          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6683          break;
6684       }
6685
6686       cellGrpCfg.spCellConfig = NULLP;
6687       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6688       if(!cellGrpCfg.spCellConfig)
6689       {
6690          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6691          break;
6692       }
6693       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6694       {
6695          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6696          break;
6697       }
6698
6699       cellGrpCfg.sCellToAddModList = NULLP;
6700       cellGrpCfg.sCellToReleaseList = NULLP;
6701       cellGrpCfg.ext1 = NULLP;
6702
6703       /* encode cellGrpCfg into duToCuRrcContainer */
6704       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6705       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6706       encBufSize = 0;
6707       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6708       /* Encode results */
6709       if(encRetVal.encoded == ENCODE_FAIL)
6710       {
6711          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6712                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6713          break;
6714       }
6715       else
6716       {
6717          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6718          for(int i=0; i< encBufSize; i++)
6719          {
6720             DU_LOG("%x",encBuf[i]);
6721          }
6722       }
6723
6724       cellGrp->size = encBufSize;
6725       CU_ALLOC(cellGrp->buf, cellGrp->size);
6726       if(!cellGrp->buf)
6727       {
6728          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6729          break;
6730       }
6731       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6732       ret = ROK;
6733       break;
6734    }
6735    FreeMemCellGrpCfg(&cellGrpCfg);
6736    return ret;
6737 }
6738
6739 /*******************************************************************
6740  *
6741  * @brief Free UE Capability RAT container
6742  *
6743  * @details
6744  *
6745  *    Function : freeUeCapRatCont
6746  *
6747  *    Functionality:
6748  *       Free UE Capability RAT conatiner
6749  *
6750  * @params[in]
6751  * @return ROK     - success
6752  *         RFAILED - failure
6753  *
6754  * ****************************************************************/
6755 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6756 {
6757    uint8_t idx;
6758    FeatureSets_t *featureSets;
6759
6760    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6761    {
6762       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6763       {
6764          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6765             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6766       }
6767       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6768    }
6769
6770    if(ueNrCap->featureSets)
6771    {
6772       featureSets = ueNrCap->featureSets;
6773       if(featureSets->featureSetsDownlinkPerCC)
6774       {
6775          if(featureSets->featureSetsDownlinkPerCC->list.array)
6776          {
6777             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6778             {
6779                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6780                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6781                         sizeof(ModulationOrder_t));
6782                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6783             }
6784             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6785          }
6786          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6787       }
6788
6789       if(featureSets->featureSetsUplinkPerCC)
6790       {
6791          if(featureSets->featureSetsUplinkPerCC->list.array)
6792          {
6793             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6794             {
6795                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6796                {
6797                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6798                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6799                          sizeof(ModulationOrder_t));
6800                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6801                }
6802             }
6803             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6804          }
6805          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6806       }
6807       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6808    }
6809 }
6810
6811 /*******************************************************************
6812  *
6813  * @brief Free UE capability RAT container list
6814  *
6815  * @details
6816  *
6817  *    Function : freeUeCapRatContList
6818  *
6819  *    Functionality: Free UE capability RAT container list
6820  *
6821  * @params[in]
6822  * @return ROK     - success
6823  *         RFAILED - failure
6824  *
6825  * ****************************************************************/
6826 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6827 {
6828    uint8_t idx;
6829    if(ueCapablityList->list.array)
6830    {
6831       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6832       {
6833          if(ueCapablityList->list.array[idx])
6834             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6835       }
6836       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6837    }
6838 }
6839
6840 /*******************************************************************
6841  *
6842  * @brief Free Handover preparation information
6843  *
6844  * @details
6845  *
6846  *    Function : freeHOPreparationInfo
6847  *
6848  *    Functionality: Free Handover preparation information
6849  *
6850  * @params[in]
6851  * @return ROK     - success
6852  *         RFAILED - failure
6853  *
6854  * ****************************************************************/
6855 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6856 {
6857    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6858
6859    if(hoPrep->criticalExtensions.choice.c1)
6860    {
6861       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6862       {
6863          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6864          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6865          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6866                sizeof(HandoverPreparationInformationRrc_IEs_t));
6867       }
6868       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6869    }
6870 }
6871
6872 /*******************************************************************
6873  *
6874  * @brief Fill feature sets
6875  *
6876  * @details
6877  *
6878  *    Function : fillFeatureSets
6879  *
6880  *    Functionality: Fill feature sets
6881  *
6882  * @params[in]
6883  * @return ROK     - success
6884  *         RFAILED - failure
6885  *
6886  * ****************************************************************/
6887 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6888 {
6889    uint8_t idx, elementCnt;
6890
6891    featureSets->featureSetsDownlink = NULLP;
6892    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6893    if(!featureSets->featureSetsDownlinkPerCC)
6894    {
6895       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6896       return RFAILED;
6897    }
6898
6899    elementCnt = 1;
6900    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6901    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6902    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6903    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6904    {
6905       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6906       return RFAILED;
6907    }
6908
6909    for(idx = 0; idx < elementCnt; idx++)
6910    {
6911       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6912       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6913       {
6914          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6915          return RFAILED;
6916       }
6917    }
6918
6919    idx = 0;
6920    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6921    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6922    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6923    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6924    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6925
6926    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6927    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6928    {
6929       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6930       return RFAILED;
6931    }
6932    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6933
6934    featureSets->featureSetsUplink = NULLP;
6935    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6936    if(!featureSets->featureSetsUplinkPerCC)
6937    {
6938       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6939       return RFAILED;
6940    }
6941
6942    elementCnt = 1;
6943    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6944    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6945    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6946    if(!featureSets->featureSetsUplinkPerCC->list.array)
6947    {
6948       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6949       return RFAILED;
6950    }
6951
6952    for(idx = 0; idx < elementCnt; idx++)
6953    {
6954       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6955       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6956       {
6957          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6958          return RFAILED;
6959       }
6960    }
6961
6962    idx = 0;
6963    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6964    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6965    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6966    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6967    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6968    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6969
6970    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6971    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6972    {
6973       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6974       return RFAILED;
6975    }
6976    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6977
6978    return ROK;
6979 }
6980
6981 /*******************************************************************
6982  *
6983  * @brief Fill UE capability RAT container
6984  *
6985  * @details
6986  *
6987  *    Function : fillUeCapRatCont
6988  *
6989  *    Functionality: Fill UE capability RAT container
6990  *
6991  * @params[in] UE Capability RAT container buffer
6992  * @return ROK     - success
6993  *         RFAILED - failure
6994  *
6995  * ****************************************************************/
6996 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6997 {
6998    uint8_t             ret = ROK;
6999    uint8_t             idx, elementCnt;
7000    asn_enc_rval_t      encRetVal;
7001    UE_NR_Capability_t  ueNrCap;
7002
7003    while(true)
7004    {
7005       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
7006
7007       /* Filling PDCP parameters */
7008       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
7009       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
7010       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
7011       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
7012       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
7013       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
7014       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
7015       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
7016       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
7017       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
7018       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
7019       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
7020       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
7021       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
7022       ueNrCap.pdcp_Parameters.shortSN = NULLP;
7023       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
7024       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
7025
7026       ueNrCap.rlc_Parameters = NULLP;
7027       ueNrCap.mac_Parameters = NULLP;
7028
7029       /* Filling PHY parameters */
7030       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
7031       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
7032       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
7033       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
7034       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
7035
7036       /* Filling RF parameters */
7037       elementCnt = 1;
7038       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
7039       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
7040       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
7041       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
7042       {
7043          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
7044          ret = RFAILED;
7045          break;
7046       }
7047
7048       for(idx = 0; idx < elementCnt; idx++)
7049       {
7050          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
7051          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
7052          {
7053             ret = RFAILED;
7054             break;
7055          }
7056       }
7057       if(ret == RFAILED)
7058          break;
7059
7060       idx = 0;
7061       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
7062       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
7063       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
7064
7065       ueNrCap.measAndMobParameters = NULLP;
7066       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
7067       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
7068       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
7069       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
7070       ueNrCap.featureSets = NULLP;
7071
7072       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
7073       if(!ueNrCap.featureSets)
7074       {
7075          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
7076          ret = RFAILED;
7077          break;
7078       }
7079
7080       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
7081       {
7082          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
7083          ret = RFAILED;
7084          break;
7085       }
7086
7087       ueNrCap.featureSetCombinations = NULLP;
7088       ueNrCap.lateNonCriticalExtension = NULLP;
7089       ueNrCap.nonCriticalExtension = NULLP;
7090
7091       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7092       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
7093       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7094       encBufSize = 0;
7095       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
7096
7097       /* Encode results */
7098       if(encRetVal.encoded == ENCODE_FAIL)
7099       {
7100          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7101             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7102          break;
7103       }
7104       else
7105       {
7106          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7107          for(int i=0; i< encBufSize; i++)
7108          {
7109             DU_LOG("%x",encBuf[i]);
7110          }
7111       }
7112
7113       ueCapRatContBuf->size = encBufSize;
7114       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
7115       if(!ueCapRatContBuf->buf)
7116       {
7117          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7118          break;
7119       }
7120       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
7121       ret = ROK;
7122       break;
7123    }
7124    freeUeCapRatCont(&ueNrCap);
7125    return ROK;
7126 }
7127
7128 /*******************************************************************
7129  *
7130  * @brief Fill UE Capability RAT container list
7131  *
7132  * @details
7133  *
7134  *    Function : fillUeCapRatContList
7135  *
7136  *    Functionality: Fill UE Capability RAT container list
7137
7138  *
7139  * @params[in] UE capability RAT container list
7140  * @return ROK     - success
7141  *         RFAILED - failure
7142  *
7143  * ****************************************************************/
7144 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
7145 {
7146     uint8_t          ret = RFAILED;
7147     uint8_t          idx, elementCnt;
7148
7149     while(true)
7150     {
7151        elementCnt = 1;
7152        ueCapablityList->list.count = elementCnt;
7153        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
7154
7155        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
7156        if(!ueCapablityList->list.array)
7157        {
7158           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7159           ret = RFAILED;
7160           break;
7161        }
7162
7163        for(idx=0; idx<elementCnt; idx++)
7164        {
7165           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
7166           if(ueCapablityList->list.array[idx] == NULLP)
7167           {
7168              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7169              ret = RFAILED;
7170              break;
7171           }
7172        }
7173        idx = 0;
7174        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
7175        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
7176        {
7177           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
7178           ret = RFAILED;
7179           break;
7180        }
7181
7182        ret = ROK;
7183        break;
7184     }
7185     return ret;
7186 }
7187
7188 /*******************************************************************
7189  *
7190  * @brief Fill UE Capability RAT container list octet string
7191  *
7192  * @details
7193  *
7194  *    Function : fillUeCapRatContListBuf
7195  *
7196  *    Functionality: Fill UE Capability RAT container list octet string
7197
7198  *
7199  * @params[in] UE capability RAT container list buffer
7200  * @return ROK     - success
7201  *         RFAILED - failure
7202  *
7203  * ****************************************************************/
7204 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
7205 {
7206    uint8_t          ret = RFAILED;
7207    asn_enc_rval_t   encRetVal;
7208    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7209
7210    while(true)
7211    {
7212       ret = fillUeCapRatContList(&ueCapablityList);
7213       if(ret != ROK)
7214       {
7215          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7216          break;
7217       }
7218
7219       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7220       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7221       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7222       encBufSize = 0;
7223       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7224             &ueCapablityList, PrepFinalEncBuf, encBuf);
7225
7226       /* Encode results */
7227       if(encRetVal.encoded == ENCODE_FAIL)
7228       {
7229          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7230                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7231          break;
7232       }
7233       else
7234       {
7235          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7236          for(int i=0; i< encBufSize; i++)
7237          {
7238             DU_LOG("%x",encBuf[i]);
7239          }
7240       }
7241
7242       ueCapablityListBuf->size = encBufSize;
7243       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7244       if(!ueCapablityListBuf->buf)
7245       {
7246          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7247          break;
7248       }
7249       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7250       ret = ROK;
7251       break;
7252    }
7253    freeUeCapRatContList(&ueCapablityList);
7254    return ret;
7255 }
7256
7257 /*******************************************************************
7258  *
7259  * @brief Free Measurement Timing Configuration
7260  *
7261  * @details
7262  *
7263  *    Function : freeMeasuementTimingConfig
7264  *
7265  *    Functionality: Free Measurement Timing Configuration
7266  *
7267  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7268  * @return void
7269  *
7270  * ****************************************************************/
7271 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7272 {
7273    uint8_t measCfgIdx;
7274    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7275    MeasTiming_t *measTiming = NULLP;
7276
7277    if(measTimingConfig.criticalExtensions.choice.c1)
7278    {
7279       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7280       {
7281          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7282          if(measTimingCfg->measTiming)
7283          {
7284             if(measTimingCfg->measTiming->list.array)
7285             {
7286                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7287                {
7288                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7289                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7290                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7291                }
7292                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7293             }
7294             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7295          }
7296          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7297       }
7298       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7299    }
7300 }
7301
7302 /*******************************************************************
7303  *
7304  * @brief Fill Measurement Timing Configuration
7305  *
7306  * @details
7307  *
7308  *    Function : fillMeasTimingCfg
7309  *
7310  *    Functionality: Fill Measurement Timing Configuration
7311  *
7312  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7313  * @return ROK     - success
7314  *         RFAILED - failure
7315  *
7316  * ****************************************************************/
7317 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7318 {
7319    uint8_t elementCnt = 0;
7320    uint8_t measCfgIdx = 0;
7321    MeasTiming_t *measTiming;
7322    SSB_MTC_t *smtc;
7323
7324    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7325    if(!measTimingCfg->measTiming)
7326    {
7327       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7328       return RFAILED;
7329    }
7330
7331    elementCnt = 1;
7332    measTimingCfg->measTiming->list.count = elementCnt;
7333    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7334    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7335    if(!measTimingCfg->measTiming->list.array)
7336    {
7337       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7338       return RFAILED;
7339    }
7340
7341    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7342    {
7343       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7344       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7345       {
7346          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7347          return RFAILED;
7348       }
7349    }
7350
7351    measCfgIdx = 0;
7352    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7353    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7354    if(!measTiming->frequencyAndTiming)
7355    {
7356       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7357       return RFAILED;
7358    }
7359
7360    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7361    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7362
7363    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7364    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7365    smtc->periodicityAndOffset.choice.sf20 = 0;
7366    smtc->duration = SSB_MTC__duration_sf1;
7367    return ROK;
7368 }
7369
7370 /*******************************************************************
7371  *
7372  * @brief Fill Measurement Timing Configuration Octet string
7373  *
7374  * @details
7375  *
7376  *    Function : fillMeasConfigBuf
7377  *
7378  *    Functionality: Fill Measurement Timing Configuration Octet string
7379
7380  *
7381  * @params[in] MeasConfig_t *measConfgBuf
7382  * @return ROK     - success
7383  *         RFAILED - failure
7384  *
7385  * ****************************************************************/
7386 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7387 {
7388    uint8_t          ret = RFAILED;
7389    asn_enc_rval_t   encRetVal;
7390    MeasurementTimingConfigurationRrc_t measTimingConfig;
7391
7392    while(true)
7393    {
7394       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7395       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7396       if(!measTimingConfig.criticalExtensions.choice.c1)
7397       {
7398          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7399          return RFAILED;
7400       }
7401       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7402
7403       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7404       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7405       {
7406          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7407          return RFAILED;
7408       }
7409
7410       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7411       if(ret != ROK)
7412       {
7413          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7414          break;
7415       }
7416
7417       /* Encode measurement timing configuration into octet string */
7418       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7419       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7420       encBufSize = 0;
7421       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7422
7423       /* Encode results */
7424       if(encRetVal.encoded == ENCODE_FAIL)
7425       {
7426          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7427                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7428          break;
7429       }
7430       else
7431       {
7432          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7433          for(int i=0; i< encBufSize; i++)
7434          {
7435             DU_LOG("%x",encBuf[i]);
7436          }
7437       }
7438
7439       measTimingConfigBuf->size = encBufSize;
7440       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7441       if(!measTimingConfigBuf->buf)
7442       {
7443          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7444          break;
7445       }
7446       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7447       ret = ROK;
7448       break;
7449    }
7450    freeMeasuementTimingConfig(measTimingConfig);
7451    return ret;
7452 }
7453
7454 /******************************************************************
7455  *
7456  * @brief Free RRC reconfiguration non-critical extension
7457  *
7458  * @details
7459  *
7460  *    Function : freeRrcReconfigNonCriticalExt
7461  *
7462  *    Functionality: Free RRC reconfiguration non-critical extension
7463  *
7464  * @params[in] RRC reconfiguration IE
7465  * @return void
7466  *
7467  * ****************************************************************/
7468 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7469 {
7470    if(rrcRecfg->masterCellGroup)
7471    {
7472       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7473    }
7474 }
7475
7476 /******************************************************************
7477  *
7478  * @brief Free measurement object addmod list
7479  *
7480  * @details
7481  *
7482  *    Function : freeMeasObjToAddModList
7483  *
7484  *    Functionality: Free measurement object add mod list
7485  *
7486  * @params[in] Measurement object add/mod list
7487  * @return void
7488  *
7489  * ****************************************************************/
7490 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7491 {
7492    uint8_t objIdx;
7493    MeasObjectNR_t *measObject;
7494
7495    if(measObjList->list.array)
7496    {
7497       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7498       {
7499          if(measObjList->list.array[objIdx])
7500          {
7501             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7502             {
7503                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7504                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7505                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7506                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7507                if(measObject->absThreshSS_BlocksConsolidation)
7508                {
7509                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7510                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7511                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7512                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7513                }
7514                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7515                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7516                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7517                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7518                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7519             }
7520             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7521          }
7522       }
7523       CU_FREE(measObjList->list.array, measObjList->list.size);
7524    }
7525 }
7526
7527 /******************************************************************
7528  *
7529  * @brief Free report config add mod list
7530  *
7531  * @details
7532  *
7533  *    Function : freeReportCfgToAddModList
7534  *
7535  *    Functionality: Free report config add mod list
7536  *
7537  * @params[in] Report config list
7538  * @return void
7539  *
7540  * ****************************************************************/
7541 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7542 {
7543    uint8_t reportCfgIdx;
7544    ReportConfigToAddMod_t *reportCfg;
7545    ReportConfigNR_t *reportCfgNr;
7546    EventTriggerConfig_t *eventTriggCfg;
7547
7548    if(reportCfgList->list.array)
7549    {
7550       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7551       {
7552          if(reportCfgList->list.array[reportCfgIdx])
7553          {
7554             reportCfg = reportCfgList->list.array[reportCfgIdx];
7555             if(reportCfg->reportConfig.choice.reportConfigNR)
7556             {
7557                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7558                if(reportCfgNr->reportType.choice.eventTriggered)
7559                {
7560                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7561                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7562                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7563                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7564                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7565                }
7566             }
7567          }
7568          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7569       }
7570       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7571    }
7572 }
7573
7574 /******************************************************************
7575  *
7576  * @brief Free measurement id to add mod list
7577  *
7578  * @details
7579  *
7580  *    Function : freeMeasIdToAddModList
7581  *
7582  *    Functionality: Free measurement id to add mod list
7583  *
7584  * @params[in] Measurement id to add mod list
7585  * @return void
7586  *
7587  * ****************************************************************/
7588 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7589 {
7590    uint8_t measIdIdx;
7591    if(measIdList->list.array)
7592    {
7593       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7594       {
7595          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7596       }
7597       CU_FREE(measIdList->list.array, measIdList->list.size);
7598    }
7599 }
7600
7601 /*******************************************************************
7602  *
7603  * @brief Free quantity config
7604  *
7605  * @details
7606  *
7607  *    Function : freeQunatityConfig
7608  *
7609  *    Functionality: Free quantity config
7610  *
7611  * @params[in] Quantity Config
7612  * @return void
7613  *
7614  * ****************************************************************/
7615 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7616 {
7617    uint8_t quanCfgIdx;
7618    QuantityConfigNR_t *quantityCfgNr;
7619
7620    if(quantityCfg->quantityConfigNR_List)
7621    {
7622       if(quantityCfg->quantityConfigNR_List->list.array)
7623       {
7624          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7625          {
7626             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7627             {
7628                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7629                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7630                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7631                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7632                if(quantityCfgNr->quantityConfigRS_Index)
7633                {
7634                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7635                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7636                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7637                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7638                }
7639                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7640             }
7641          }
7642          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7643       }
7644       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7645    }
7646 }
7647
7648 /******************************************************************
7649  *
7650  * @brief Free measurement Config
7651  *
7652  * @details
7653  *
7654  *    Function : freeMeasConfig
7655  *
7656  *    Functionality: Free measurement config
7657  *
7658  * @params[in] Measurement config
7659  * @return void
7660  *
7661  * ****************************************************************/
7662 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7663 {
7664    if(measConfig->measObjectToAddModList)
7665    {
7666       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7667       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7668    }
7669    if(measConfig->reportConfigToAddModList)
7670    {
7671       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7672       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7673    }
7674    if(measConfig->measIdToAddModList)
7675    {
7676       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7677       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7678    }
7679    if(measConfig->s_MeasureConfig)
7680    {
7681       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7682    }
7683    if(measConfig->quantityConfig)
7684    {
7685       freeQuantityConfig(measConfig->quantityConfig);
7686       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7687    }
7688 }
7689 /******************************************************************
7690  *
7691  * @brief Free DRB to AddMod List
7692  *
7693  * @details
7694  *
7695  *    Function : freeDrbToAddModList
7696  *
7697  *    Functionality: Free SRB to AddMod List
7698  *
7699  * @params[in] SBR to add/mod list
7700  * @return void
7701  *
7702  * ****************************************************************/
7703 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7704 {
7705    uint8_t drbIdx;
7706    if(drbToAddList->list.array)
7707    {
7708       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7709       {
7710          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7711          {
7712             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7713             {
7714                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7715                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7716                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7717                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7718             }
7719             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7720             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7721          }
7722          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7723       }
7724       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7725    }
7726 }
7727
7728 /******************************************************************
7729  *
7730  * @brief Free SRB to AddMod List
7731  *
7732  * @details
7733  *
7734  *    Function : freeSrbToAddModList
7735  *
7736  *    Functionality: Free SRB to AddMod List
7737  *
7738  * @params[in] SBR to add/mod list
7739  * @return void
7740  *
7741  * ****************************************************************/
7742 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7743 {
7744    uint8_t srbIdx;
7745    if(srbToAddList->list.array)
7746    {
7747       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7748       {
7749          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7750          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7751          {
7752             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7753             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7754          }
7755
7756          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7757       }
7758       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7759    }
7760 }
7761
7762 /******************************************************************
7763  *
7764  * @brief Free Radio Bearer Config
7765  *
7766  * @details
7767  *
7768  *    Function : freeRadioBearerConfig
7769  *
7770  *    Functionality: Free Radio Bearer config
7771  *
7772  * @params[in] Radio bearer config
7773  * @return void
7774  *
7775  * ****************************************************************/
7776 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7777 {
7778    if(radioBearerConfig->srb_ToAddModList)
7779    {
7780       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7781       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7782    }
7783    if(radioBearerConfig->drb_ToAddModList)
7784    {
7785       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7786       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7787    }
7788 }
7789
7790 /******************************************************************
7791  *
7792  * @brief Free reconfiguration message
7793  *
7794  * @details
7795  *
7796  *    Function : freeRrcReconfig
7797  *
7798  *    Functionality: Free reconfiguration message
7799  *
7800  * @params[in] RRC Reconfiguration message
7801  * @return void
7802  *
7803  * ****************************************************************/
7804 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7805 {
7806    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7807    {
7808       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7809       {
7810          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7811          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7812       }
7813       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7814       {
7815          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7816          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7817       }
7818       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7819       {
7820          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7821          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7822       }
7823       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7824    }
7825 }
7826
7827 /******************************************************************
7828  *
7829  * @brief Fill SRB To Add Mod list
7830  *
7831  * @details
7832  *
7833  *    Function : fillSrbToAddModList
7834  *
7835  *    Functionality: fill SRB to Add Mod list
7836  *
7837  * @params[in] UE control block
7838  *             SRB to Add/Mod list
7839  * @return ROK     - success
7840  *         RFAILED - failure
7841  *
7842  * ****************************************************************/
7843 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7844 {
7845    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7846
7847    if(updateAllRbCfg)
7848       elementCnt = ueCb->numSrb;
7849    else
7850    {
7851       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7852       {
7853          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7854             elementCnt++;
7855       }
7856    }
7857
7858    if(!elementCnt)
7859    {
7860       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7861       return ROK;
7862    }
7863
7864    srbToAddList->list.count = elementCnt;
7865    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7866
7867    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7868    if(!srbToAddList->list.array)
7869    {
7870       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7871       return RFAILED;
7872    }
7873
7874    srbIdx = 0;
7875    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7876    {
7877       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7878          continue;
7879
7880       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7881       if(!srbToAddList->list.array[srbIdx])
7882       {
7883          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7884          return RFAILED;
7885       }
7886
7887       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7888
7889       /* Reestablish PDCP */
7890       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7891       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7892       {
7893          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7894          return RFAILED;
7895       }
7896       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7897
7898       /* PDCP configuration */
7899       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7900       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7901       {
7902          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7903          return RFAILED;
7904       }
7905
7906       /* Reordering timer */
7907       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7908       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7909       {
7910          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7911          return RFAILED;
7912       }
7913       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7914
7915       srbIdx++;
7916    }
7917    return ROK;
7918 }
7919
7920 /******************************************************************
7921  *
7922  * @biief Fill DRBeTo Add Mod list
7923  *
7924  * @details
7925  *
7926  *    Function : fillDrbToAddModList
7927  *
7928  *    Functionality: fill DRB to Add Mod list
7929  *
7930  * @params[in] UE control block
7931  *             DRB to Add/Mod list
7932  * @return ROK     - success
7933  *         RFAILED - failure
7934  *
7935  * ****************************************************************/
7936 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7937 {
7938    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7939
7940    if(updateAllRbCfg)
7941       elementCnt = ueCb->numDrb;
7942    else
7943    {
7944       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7945       {
7946          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7947             elementCnt++;
7948       }
7949    }
7950
7951    if(!elementCnt)
7952    {
7953       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7954       return ROK;
7955    }
7956
7957
7958    drbToAddList->list.count = elementCnt;
7959    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7960
7961    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7962    if(!drbToAddList->list.array)
7963    {
7964       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7965       return RFAILED;
7966    }
7967
7968    drbIdx = 0;
7969    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7970    {
7971       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7972          continue;
7973
7974       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7975       if(!drbToAddList->list.array[drbIdx])
7976       {
7977          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7978          return RFAILED;
7979       }
7980
7981       /* DRB Id */
7982       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7983
7984       /* PDCP Config */
7985       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7986       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7987       {
7988          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7989          return RFAILED;
7990       }
7991
7992       /* PDCP Config -> DRB */
7993       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7994       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7995       {
7996          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7997          return RFAILED;
7998       }
7999
8000       /* DRB -> Discard Timer */
8001       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
8002       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
8003       {
8004          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
8005          return RFAILED;
8006       }
8007       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
8008
8009       /* UL PDCP SN length */
8010       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
8011       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
8012       {
8013          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
8014          return RFAILED;
8015       }
8016       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
8017
8018       /* DL PDCP SN length */
8019       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
8020       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
8021       {
8022          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
8023          return RFAILED;
8024       }
8025       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
8026
8027       /* Header Compression */
8028       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
8029        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
8030
8031       /* Reordering timer */
8032       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
8033       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
8034       {
8035          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
8036          return RFAILED;
8037       }
8038       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
8039
8040       drbIdx++;
8041    }
8042
8043    return ROK;
8044 }
8045
8046 /******************************************************************
8047  *
8048  * @brief Fill Radio bearer configuration
8049  *
8050  * @details
8051  *
8052  *    Function : fillRadioBearerConfig
8053  *
8054  *    Functionality: Fill Radio bearer configuration
8055  *
8056  * @params[in] UE control block
8057  *             Radio bearer config pointer
8058  * @return ROK     - success
8059  *         RFAILED - failure
8060  *
8061  * ****************************************************************/
8062 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
8063 {
8064    /* SRB To Add/Mod List */
8065    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
8066    if(!radioBearerConfig->srb_ToAddModList)
8067    {
8068       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
8069       return RFAILED;
8070    }
8071    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
8072    {
8073       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
8074       return RFAILED;
8075    }
8076
8077    /* DRB To Add/Mod List */
8078    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
8079    if(!radioBearerConfig->drb_ToAddModList)
8080    {
8081       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
8082       return RFAILED;
8083     }
8084    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
8085    {
8086       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
8087       return RFAILED;
8088    }
8089
8090    return ROK;
8091 }
8092
8093 /*******************************************************************
8094  *
8095  * @brief Fill measurement object to add/mod list
8096  *
8097  * @details
8098  *
8099  *    Function : fillMeasObjToAddModList
8100  *
8101  *    Functionality: Fill measurement object to add/mod list
8102  *
8103  * @params[in] Measurement object to add/mod list
8104  * @return ROK     - success
8105  *         RFAILED - failure
8106  *
8107  * ****************************************************************/
8108 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
8109 {
8110    uint8_t elementCnt, objIdx;
8111    MeasObjectNR_t *measObject;
8112
8113    elementCnt = 1;
8114    measObjList->list.count = elementCnt;
8115    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
8116
8117    CU_ALLOC(measObjList->list.array, measObjList->list.size);
8118    if(!measObjList->list.array)
8119    {
8120       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
8121       return RFAILED;
8122    }
8123
8124    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
8125    {
8126       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
8127       if(!measObjList->list.array[objIdx])
8128       {
8129          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
8130          return RFAILED;
8131       }
8132    }
8133
8134    objIdx = 0;
8135    measObjList->list.array[objIdx]->measObjectId = 1;
8136    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
8137    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
8138    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
8139    {
8140       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
8141       return RFAILED;
8142    }
8143
8144    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
8145
8146    /* SSB frequency */
8147    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
8148    if(!measObject->ssbFrequency)
8149    {
8150       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
8151       return RFAILED;
8152    }
8153    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
8154
8155    /* Subcarrier spacing */
8156    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8157    if(!measObject->ssbSubcarrierSpacing)
8158    {
8159       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
8160       return RFAILED;
8161    }
8162    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
8163
8164    /* SMTC1 */
8165    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
8166    if(!measObject->smtc1)
8167    {
8168       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
8169       return RFAILED;
8170    }
8171    measObject->smtc1->duration = SSB_MTC__duration_sf1;
8172    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
8173    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
8174
8175    /* Absoulute threshold SSB consolidation */
8176    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
8177    if(!measObject->absThreshSS_BlocksConsolidation)
8178    {
8179       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
8180       return RFAILED;
8181    }
8182
8183    /* RSRP threshold */
8184    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
8185    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
8186    {
8187       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
8188       return RFAILED;
8189    }
8190    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
8191
8192    /* RSRQ threshold */
8193    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
8194    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
8195    {
8196       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
8197       return RFAILED;
8198    }
8199    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
8200
8201    /* SINR threshold */
8202    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
8203    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
8204    {
8205       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
8206       return RFAILED;
8207    }
8208    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8209
8210    /* Number of SSBs to average */
8211    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8212    if(!measObject->nrofSS_BlocksToAverage)
8213    {
8214       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8215       return RFAILED;
8216    }
8217    *(measObject->nrofSS_BlocksToAverage) = 2;
8218
8219    /* Quantity Config index */
8220    measObject->quantityConfigIndex = 1;
8221
8222    /* Offset MO */
8223    /* RSRP offset for SSB */
8224    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8225    if(!measObject->offsetMO.rsrpOffsetSSB)
8226    {
8227       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8228       return RFAILED;
8229    }
8230    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8231
8232    /* RSRQ offset for SSB */
8233    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8234    if(!measObject->offsetMO.rsrpOffsetSSB)
8235    {
8236       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8237       return RFAILED;
8238    }
8239    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8240
8241    /* SINR offset for SSB */
8242    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8243    if(!measObject->offsetMO.sinrOffsetSSB)
8244    {
8245       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8246       return RFAILED;
8247    }
8248    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8249
8250    return ROK;
8251 }
8252
8253 /*******************************************************************
8254  *
8255  * @brief Fill Report configuration to Add/mod list
8256  *
8257  * @details
8258  *
8259  *    Function : fillReportCfgToAddModList
8260  *
8261  *    Functionality: Fill Report configuration to Add/mod list
8262  *
8263  * @params[in] Report Config To Add/Mod List
8264  * @return ROK     - success
8265  *         RFAILED - failure
8266  *
8267  * ****************************************************************/
8268 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8269 {
8270    uint8_t elementCnt;
8271    uint8_t reportCfgIdx;
8272    ReportConfigToAddMod_t *reportCfg;
8273    ReportConfigNR_t *reportCfgNr;
8274    EventTriggerConfig_t *eventTriggCfg;
8275
8276    elementCnt = 1;
8277    reportCfgList->list.count = elementCnt;
8278    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8279
8280    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8281    if(!reportCfgList->list.array)
8282    {
8283       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8284       return RFAILED;
8285    }
8286
8287    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8288    {
8289       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8290       if(!reportCfgList->list.array[reportCfgIdx])
8291       {
8292          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8293          return RFAILED;
8294       }
8295    }
8296
8297    reportCfgIdx = 0;
8298    reportCfg = reportCfgList->list.array[reportCfgIdx];
8299    reportCfg->reportConfigId = 1;
8300    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8301
8302    /* Report Configuration for NR */
8303    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8304    if(!reportCfg->reportConfig.choice.reportConfigNR)
8305    {
8306       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8307       return RFAILED;
8308    }
8309    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8310
8311    /* Report Type */
8312    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8313    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8314    if(!reportCfgNr->reportType.choice.eventTriggered)
8315    {
8316       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8317       return RFAILED;
8318    }
8319    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8320
8321    /* Event 3 */
8322    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8323    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8324    if(!eventTriggCfg->eventId.choice.eventA3)
8325    {
8326       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8327       return RFAILED;
8328    }
8329
8330    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8331    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8332    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8333    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8334    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8335    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8336
8337    /* Reference Signal Type */
8338    eventTriggCfg->rsType = NR_RS_Type_ssb;
8339
8340    /* Report Interval */
8341    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8342
8343    /* Report Amount */
8344    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8345
8346    /* Report Quantity cell */
8347    eventTriggCfg->reportQuantityCell.rsrp = true;
8348    eventTriggCfg->reportQuantityCell.rsrq = false;
8349    eventTriggCfg->reportQuantityCell.sinr = false;
8350
8351    /* Maximum reported cells */
8352    eventTriggCfg->maxReportCells = 3;
8353
8354    /* Report qunatity RS Indexes */
8355    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8356    if(!eventTriggCfg->reportQuantityRS_Indexes)
8357    {
8358       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8359       return RFAILED;
8360    }
8361    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8362    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8363    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8364
8365    /* Maximum number of RS indexes to report */
8366    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8367    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8368    {
8369       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8370       return RFAILED;
8371    }
8372    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8373
8374    /* Include Beam measurement */
8375    eventTriggCfg->includeBeamMeasurements = false;
8376
8377    return ROK;
8378 }
8379
8380 /*******************************************************************
8381  *
8382  * @brief Fill measurement Id to add/mod list
8383
8384  * @details
8385  *
8386  *    Function : fillMeasIdToAddModList
8387  *
8388  *    Functionality: Fill measurement Id to add/mod list
8389  *
8390  * @params[in] Measurement Id to add/mod list
8391  * @return ROK     - success
8392  *         RFAILED - failure
8393  *
8394  * ****************************************************************/
8395 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8396 {
8397    uint8_t elementCnt;
8398    uint8_t measIdIdx;
8399
8400    elementCnt = 1;
8401    measIdList->list.count = elementCnt;
8402    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8403
8404    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8405    if(!measIdList->list.array)
8406    {
8407       return RFAILED;
8408    }
8409
8410    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8411    {
8412       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8413       if(!measIdList->list.array[measIdIdx])
8414       {
8415          return RFAILED;
8416       }
8417
8418       measIdIdx=0;
8419       measIdList->list.array[measIdIdx]->measId = 1;
8420       measIdList->list.array[measIdIdx]->measObjectId = 1;
8421       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8422    }
8423    return ROK;
8424 }
8425
8426 /*******************************************************************
8427  *
8428  * @brief Fill s-measurement configuration
8429  *
8430  * @details
8431  *
8432  *    Function : fillSMeasConfig
8433  *
8434  *    Functionality: Fill s-measurement configuration
8435  *
8436  * @params[in] s-Measurement config
8437  * @return ROK     - success
8438  *         RFAILED - failure
8439  *
8440  * ****************************************************************/
8441 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8442 {
8443    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8444    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8445
8446    return ROK;
8447 }
8448
8449 /*******************************************************************
8450  *
8451  * @brief Fill quantity config
8452  *
8453  * @details
8454  *
8455  *    Function : fillQunatityConfig
8456  *
8457  *    Functionality: Fill quantity config
8458  *
8459  * @params[in] Quantity Config
8460  * @return ROK     - success
8461  *         RFAILED - failure
8462  *
8463  * ****************************************************************/
8464 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8465 {
8466    uint8_t elementCnt = 0;
8467    uint8_t quanCfgIdx = 0;
8468    QuantityConfigNR_t *quantityCfgNr;
8469
8470    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8471    if(!quantityCfg->quantityConfigNR_List)
8472    {
8473       return RFAILED;
8474    }
8475
8476    elementCnt = 1;
8477    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8478    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8479
8480    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8481    if(!quantityCfg->quantityConfigNR_List->list.array)
8482    {
8483       return RFAILED;
8484    }
8485
8486    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8487    {
8488       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8489       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8490       {
8491          return RFAILED;
8492       }
8493    }
8494
8495    quanCfgIdx = 0;
8496    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8497
8498    /* Quantity Config of Reference signal */
8499    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8500    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8501    {
8502       return RFAILED;
8503    }
8504    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8505
8506    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8507    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8508    {
8509       return RFAILED;
8510    }
8511    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8512
8513    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8514    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8515    {
8516       return RFAILED;
8517    }
8518    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8519
8520    /* Quantity Config RS index */
8521    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8522    if(!quantityCfgNr->quantityConfigRS_Index)
8523    {
8524       return RFAILED;
8525    }
8526
8527    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8528    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8529    {
8530       return RFAILED;
8531    }
8532    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8533
8534    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8535    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8536    {
8537       return RFAILED;
8538    }
8539    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8540
8541    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8542    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8543    {
8544       return RFAILED;
8545    }
8546    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8547
8548    return ROK;
8549 }
8550
8551 /*******************************************************************
8552  *
8553  * @brief Fill measurement configuration
8554  *
8555  * @details
8556  *
8557  *    Function : fillMeasConfig
8558  *
8559  *    Functionality: Fill measurement configuration
8560  *
8561  * @params[in] Measurement config
8562  * @return ROK     - success
8563  *         RFAILED - failure
8564  *
8565  * ****************************************************************/
8566 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8567 {
8568    /* Measurement object to add/mod list */
8569    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8570    if(!measConfig->measObjectToAddModList)
8571    {
8572       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8573       return RFAILED;
8574    }
8575    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8576    {
8577       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8578       return RFAILED;
8579    }
8580
8581    /* Report Config To add/mod list */
8582    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8583    if(!measConfig->reportConfigToAddModList)
8584    {
8585       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8586       return RFAILED;
8587    }
8588    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8589    {
8590       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8591       return RFAILED;
8592    }
8593
8594    /* Measurement Id to add/mod list */
8595    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8596    if(!measConfig->measIdToAddModList)
8597    {
8598       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8599       return RFAILED;
8600    }
8601    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8602    {
8603       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8604       return RFAILED;
8605    }
8606
8607    /* S-Measurement config */
8608    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8609    if(!measConfig->s_MeasureConfig)
8610    {
8611       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8612       return RFAILED;
8613    }
8614    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8615    {
8616       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8617       return RFAILED;
8618    }
8619
8620    /* Qunatity Config */
8621    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8622    if(!measConfig->quantityConfig)
8623    {
8624       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8625       return RFAILED;
8626    }
8627    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8628    {
8629       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8630       return RFAILED;
8631    }
8632
8633 return ROK;
8634 }
8635
8636 /*******************************************************************
8637  *
8638  * @brief Fill RRC reconfiguration non-critical extension IE
8639  *
8640  * @details
8641  *
8642  *    Function : fillRrcReconfigNonCriticalExt
8643  *
8644  *    Functionality: Fill RRC reconfiguration non-critical extension
8645  *
8646  * @params[in] RRC Reconfig Non-critical extension
8647  * @return ROK     - success
8648  *         RFAILED - failure
8649  *
8650  * ****************************************************************/
8651 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8652 {
8653    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8654    if(!rrcRecfg->masterCellGroup)
8655    {
8656       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8657       return RFAILED;
8658    }
8659
8660    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8661    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8662    if(!rrcRecfg->masterCellGroup->buf)
8663    {
8664       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8665       return RFAILED;
8666    }
8667    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8668
8669 #if 0
8670    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8671     * received from DU */
8672    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8673    {
8674       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8675       return RFAILED;
8676    }
8677 #endif
8678
8679    return ROK;
8680 }
8681
8682 /*******************************************************************
8683  *
8684  * @brief Fill RRC reconfiguration structure
8685  *
8686  * @details
8687  *
8688  *    Function : fillRrcReconfig
8689  *
8690  *    Functionality: Fill RRC reconfiguration
8691
8692  *
8693  * @params[in] UE Cb
8694  *             RRC reconfiguration structure
8695  * @return ROK     - success
8696  *         RFAILED - failure
8697  *
8698  * ****************************************************************/
8699 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8700 {
8701    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8702
8703    rrcReconfig->rrc_TransactionIdentifier = 1;
8704    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8705
8706    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8707    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8708    {
8709       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8710       return RFAILED;
8711    }
8712
8713    /* Radio Bearer Configuration */
8714    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8715    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8716    {
8717       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8718       return RFAILED;
8719    }
8720    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8721    {
8722       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8723       return RFAILED;
8724    }
8725
8726    /* Measurement Configuration */
8727    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8728    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8729    {
8730       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8731       return RFAILED;
8732    }
8733    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8734    {
8735       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8736       return RFAILED;
8737    }
8738
8739    /* Non Critical extension */
8740    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8741    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8742    {
8743       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8744       return RFAILED;
8745    }
8746    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8747    {
8748       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8749       return RFAILED;
8750    }
8751    return ROK;
8752 }
8753
8754 /*******************************************************************
8755  *
8756  * @brief Fill RRC reconfiguration Octet string
8757  *
8758  * @details
8759  *
8760  *    Function : fillRrcReconfigBuf
8761  *
8762  *    Functionality: Fill RRC reconfiguration octet string
8763
8764  *
8765  * @params[in] OCTET_STRING_t buffer
8766  * @return ROK     - success
8767  *         RFAILED - failure
8768  *
8769  * ****************************************************************/
8770 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8771 {
8772    uint8_t          ret = RFAILED;
8773    asn_enc_rval_t   encRetVal;
8774    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8775    rrcReconfig = &rrcRecfg;
8776
8777    while(true)
8778    {
8779       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8780       {
8781          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8782          break;
8783       }
8784
8785       /* Encode RRC Reconfiguration */
8786       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8787       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8788       encBufSize = 0;
8789       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8790
8791       /* Encode results */
8792       if(encRetVal.encoded == ENCODE_FAIL)
8793       {
8794          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8795                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8796          break;
8797       }
8798       else
8799       {
8800          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8801          for(int i=0; i< encBufSize; i++)
8802          {
8803             DU_LOG("%x",encBuf[i]);
8804          }
8805       }
8806
8807       rrcReconfigBuf->size = encBufSize;
8808       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8809       if(!rrcReconfigBuf->buf)
8810       {
8811          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8812          break;
8813       }
8814       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8815       ret = ROK;
8816       break;
8817    }
8818
8819    freeRrcReconfig(rrcReconfig);
8820    return ret;
8821 }
8822
8823 /*******************************************************************
8824  *
8825  * @brief Fill HO preparation information Octet string
8826  *
8827  * @details
8828  *
8829  *    Function : fillHOPreparationInfoBuf
8830  *
8831  *    Functionality: Fill HO preparation information Octet string
8832
8833  *
8834  * @params[in] HandoverPreparationInformation_t buffer
8835  * @return ROK     - success
8836  *         RFAILED - failure
8837  *
8838  * ****************************************************************/
8839 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8840 {
8841    uint8_t          ret = RFAILED;
8842    asn_enc_rval_t   encRetVal;
8843    HandoverPreparationInformationRrc_t hoPrepInfo;
8844    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8845
8846    while(true)
8847    {
8848
8849       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8850       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8851       if(!hoPrepInfo.criticalExtensions.choice.c1)
8852       {
8853          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8854          break;
8855       }
8856       hoPrepInfo.criticalExtensions.choice.c1->present = \
8857          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8858
8859       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8860          sizeof(HandoverPreparationInformationRrc_IEs_t));
8861       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8862       {
8863          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8864          break;
8865       }
8866       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8867
8868       /* Fill UE Capability RAT container list */
8869       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8870       if(ret != ROK)
8871       {
8872          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8873          break;
8874       }
8875
8876       /* Fill Source config */
8877       hoPrepInfoIe->sourceConfig = NULLP;
8878       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8879       if(!hoPrepInfoIe->sourceConfig)
8880       {
8881          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8882          return RFAILED;
8883       }
8884       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8885
8886       if(ret != ROK)
8887       {
8888          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8889          return RFAILED;
8890       }
8891
8892       hoPrepInfoIe->rrm_Config = NULLP;
8893       hoPrepInfoIe->as_Context = NULLP;
8894       hoPrepInfoIe->nonCriticalExtension = NULLP;
8895
8896       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8897       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8898       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8899       encBufSize = 0;
8900       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8901             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8902
8903       /* Encode results */
8904       if(encRetVal.encoded == ENCODE_FAIL)
8905       {
8906          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8907                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8908          break;
8909       }
8910       else
8911       {
8912          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8913          for(int i=0; i< encBufSize; i++)
8914          {
8915             DU_LOG("%x",encBuf[i]);
8916          }
8917       }
8918
8919       hoPrepInfoBuf->size = encBufSize;
8920       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8921       if(!hoPrepInfoBuf->buf)
8922       {
8923          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8924          break;
8925       }
8926       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8927       ret = ROK;
8928       break;
8929    }
8930    freeHOPreparationInfo(&hoPrepInfo);
8931    return ret;
8932 }
8933
8934 /*******************************************************************
8935  *
8936  * @brief Fills CuToDuContainer
8937  *
8938  * @details
8939  *
8940  *    Function : fillCuToDuContainer
8941  *
8942  *    Functionality: Fills CuToDuContainer
8943  *
8944  * @params[in] pointer to CUtoDURRCInformation_t
8945  *
8946  * @return ROK     - success
8947  *         RFAILED - failure
8948  *
8949  ******************************************************************/
8950
8951 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8952 {
8953    uint8_t elementCnt = 0;
8954    uint8_t ret = ROK;
8955    uint8_t idx;
8956
8957    /* UE Capabulity RAT Container List */
8958    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8959    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8960    {
8961       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8962       return RFAILED;
8963    }
8964    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8965
8966    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8967    if(!rrcMsg->measConfig)
8968    {
8969       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8970       return RFAILED;
8971    }
8972    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8973
8974    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8975    {
8976       /* IE extensions */
8977       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8978       if(rrcMsg->iE_Extensions)
8979       {
8980          elementCnt = 1;
8981          rrcMsg->iE_Extensions->list.count = elementCnt;
8982          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8983
8984          /* Initialize the CUtoDURRCInformation_ExtIEs */
8985          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8986
8987          if(rrcMsg->iE_Extensions->list.array == NULLP)
8988          {
8989             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8990             ret = RFAILED;
8991          }
8992
8993          for(idx=0; idx<elementCnt; idx++)
8994          {
8995             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8996             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8997             {
8998                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8999                ret = RFAILED;
9000             }
9001          }
9002
9003          idx = 0;
9004 #if 0
9005          /* Cell Group Configuration */
9006          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
9007          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9008          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
9009                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
9010          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
9011          idx++;
9012 #endif
9013          /* Handover Preparation Information */
9014          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
9015          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9016          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
9017                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
9018          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
9019       }
9020    }
9021    return ret;
9022 }
9023 /*******************************************************************
9024  *
9025  * @brief Build the drx cycle
9026  *
9027  * @details
9028  *
9029  *    Function : BuildDrxCycle
9030  *
9031  *    Functionality: Build drx cycle IE
9032  *
9033  * @params[in] pointer to DRXCycle_t
9034  *
9035  * @return ROK     - success
9036  *         RFAILED - failure
9037  *
9038  ******************************************************************/
9039 uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
9040 {
9041    drxCycle->longDRXCycleLength = LongDRXCycleLength_ms40;
9042    CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
9043    if(!drxCycle->shortDRXCycleLength)
9044    {
9045       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleLength");
9046       return RFAILED;
9047    }
9048    *(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
9049
9050    CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
9051    if(!drxCycle->shortDRXCycleTimer)
9052    {
9053       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleTimer");
9054       return RFAILED;
9055    }
9056    *(drxCycle->shortDRXCycleTimer) = 4;
9057    return ROK;
9058 }
9059 /*******************************************************************
9060  *
9061  * @brief Free CuToDuContainer
9062  *
9063  * @details
9064  *
9065  *    Function : FreeCuToDuInfo
9066  *
9067  *    Functionality: Free CuToDuContainer
9068  *
9069  * @params[in] pointer to CUtoDURRCInformation_t
9070  *
9071  * @return ROK     - success
9072  *         RFAILED - failure
9073  *
9074  ******************************************************************/
9075
9076 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9077 {
9078    uint8_t idx, idx2;
9079
9080    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9081    {
9082       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9083          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
9084       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9085    }
9086    if(rrcMsg->iE_Extensions)
9087    {
9088       if(rrcMsg->iE_Extensions->list.array)
9089       {
9090          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
9091          {
9092             if(rrcMsg->iE_Extensions->list.array[idx])
9093             {
9094                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
9095                {
9096                   case ProtocolIE_ID_id_CellGroupConfig:
9097                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9098                      {
9099                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
9100                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
9101
9102                      }
9103                      break;
9104                   default:
9105                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9106                            rrcMsg->iE_Extensions->list.array[idx]->id);
9107                      break;
9108                }
9109             }
9110             break;
9111          }
9112          for(idx2 = 0; idx2 < idx; idx2++)
9113          {
9114             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
9115          }
9116          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9117
9118       }
9119
9120       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9121    }
9122 }
9123 /*******************************************************************
9124  *
9125  * @brief Builds and sends the UE Setup Request
9126  *
9127  * @details
9128  *
9129  *    Function : BuildAndSendUeContextSetupReq
9130  *
9131  *    Functionality: Constructs the UE Setup Request and sends
9132  *                   it to the CU through SCTP.
9133  *
9134  * @params[in]
9135  *
9136  * @return ROK     - success
9137  *         RFAILED - failure
9138  *
9139  * ****************************************************************/
9140 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
9141 {
9142    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
9143    uint8_t   ret= RFAILED, ret1;
9144    uint8_t   elementCnt;
9145    uint8_t   idx, idx1, bufLen, duIdx;
9146    uint32_t  spCellId;
9147    DuDb      *targetDuDb = NULLP;
9148    F1AP_PDU_t           *f1apMsg = NULLP;
9149    UEContextSetupRequest_t *ueSetReq = NULLP;
9150    asn_enc_rval_t encRetVal;        /* Encoder return value */
9151    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9152
9153    while(true)
9154    {
9155       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
9156
9157       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9158       if(f1apMsg == NULLP)
9159       {
9160          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9161          break;
9162       }
9163
9164       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9165       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9166       if(f1apMsg->choice.initiatingMessage == NULLP)
9167       {
9168          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
9169          break;
9170       }
9171
9172       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
9173       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9174       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
9175
9176       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9177
9178       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9179          elementCnt = 7;
9180       else
9181       {
9182 #ifdef NR_DRX
9183          elementCnt = 12;
9184 #else
9185          elementCnt = 11;
9186 #endif
9187       }
9188       ueSetReq->protocolIEs.list.count = elementCnt;
9189       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
9190
9191       /* Initialize the UESetup members */
9192       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
9193
9194       if(ueSetReq->protocolIEs.list.array == NULLP)
9195       {
9196          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
9197          break;
9198       }
9199
9200       for(idx1=0; idx1<elementCnt; idx1++)
9201       {
9202          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
9203          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
9204          {
9205             break;
9206          }
9207       }
9208
9209       idx = 0;
9210
9211       /*GNB CU UE F1AP ID*/
9212       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9213       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9214       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
9215       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
9216
9217       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9218       {
9219          /*GNB DU UE F1AP ID*/
9220          idx++;
9221          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9222          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9223          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
9224          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
9225       }
9226
9227       /*Special Cell ID*/
9228       idx++;
9229       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
9230       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9231       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
9232       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9233       {
9234          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
9235          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
9236          /* Since we are supporting only one cell per DU, accessing 0th index to
9237           * get target cell info */
9238          spCellId = targetDuDb->cellCb[0].nrCellId;
9239       }
9240       else
9241          spCellId = ueCb->cellCb->nrCellId;
9242       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
9243       if(Nrcgiret != ROK)
9244       {
9245          break;
9246       }
9247
9248       /*Served Cell Index*/
9249       idx++;
9250       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9251       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9252       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9253       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9254
9255       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9256       {
9257          /*CellULConfigured*/
9258          idx++;
9259          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9260          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9261          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9262          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9263       }
9264
9265       /*CUtoDURRCContainer*/
9266       idx++;
9267       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9268       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9269       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9270       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9271       {
9272          break;
9273       }
9274
9275       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9276       {
9277          /*Drx cycle*/
9278 #ifdef NR_DRX
9279          idx++;
9280          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_DRXCycle;
9281          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9282          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
9283          if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
9284          {
9285             DU_LOG("\nERROR  -->  F1AP : Failed to build drx cycle");
9286             break;
9287          }
9288 #endif
9289          /*Special Cells to be SetupList*/
9290          idx++;
9291          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9292          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9293          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9294          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9295          if(SplCellListret != ROK)
9296          {
9297             break;
9298          }
9299       }
9300
9301       /*SRBs To Be Setup List*/
9302       idx++;
9303       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9304       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9305       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9306       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9307       if(SrbSetupret != ROK)
9308       {
9309          break;
9310       }
9311
9312       /*DRBs to Be Setup List*/
9313       idx++;
9314       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9315       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9316       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9317       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9318       if(ret1 != ROK)
9319       {
9320          break;
9321       }
9322
9323       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9324       {
9325          /* RRC delivery status request */
9326          idx++;
9327          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9328          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9329          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9330          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9331       }
9332
9333       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9334       idx++;
9335       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9336       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9337       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9338
9339       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9340       bufLen = 4;
9341       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9342       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9343             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9344       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9345       {
9346          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9347          break;
9348       }
9349       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9350       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9351
9352       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9353
9354       /* Encode the F1SetupRequest type as APER */
9355       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9356       encBufSize = 0;
9357       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9358
9359       /* Encode results */
9360       if(encRetVal.encoded == ENCODE_FAIL)
9361       {
9362          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9363                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9364          break;
9365       }
9366       else
9367       {
9368          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9369          for(int i=0; i< encBufSize; i++)
9370          {
9371             DU_LOG("%x",encBuf[i]);
9372          }
9373       }
9374
9375       /* Sending  msg  */
9376       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9377       {
9378          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9379          break;
9380       }
9381       ret = ROK;
9382       break;
9383    }
9384    FreeUeContextSetupReq(f1apMsg);
9385
9386    return ret;
9387 }/* End of BuildAndSendUeContextSetupReq*/
9388
9389 /**********************************************************************
9390  * @brief Function to extractTeId received in UE context setup Response
9391  *
9392  * @details
9393  *
9394  *    Function : extractTeId
9395  *
9396  *    Functionality:
9397  *         - Function to extract TeId
9398  *
9399  * @params[in]
9400  * @return ROK     - success
9401  *         RFAILED - failure
9402  *
9403  **********************************************************************/
9404 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9405 {
9406    uint8_t arrIdx = 0;
9407    uint32_t teId = 0;
9408    GTPTunnel_t *gtpDl = NULLP;
9409
9410    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9411    {
9412       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9413       {
9414          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9415          {
9416             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9417             if(gtpDl->gTP_TEID.size > 0)
9418             {
9419                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9420             }
9421             else
9422                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9423             return(teId);
9424          }
9425       }
9426    }
9427    return teId;
9428 }
9429
9430 /****************************************************************
9431  * @brief Function to add Drb tunnels
9432  *
9433  * @details
9434  *
9435  *    Function : addDrbTunnels
9436  *
9437  *    Functionality:
9438  *         - Function to add Drb tunnels
9439  *
9440  * @params[in]
9441  * @return ROK     - success
9442  *         RFAILED - failure
9443  *
9444  * ****************************************************************/
9445 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9446 {
9447    uint8_t ret = ROK;
9448    EgtpTnlEvt tnlEvt;
9449
9450    if(teId > MAX_TEID || teId < MIN_TEID)
9451    {
9452       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9453    }
9454    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9455    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9456    tnlEvt.lclTeid = teId;
9457    tnlEvt.remTeid = teId;
9458    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9459    if(ret != ROK)
9460    {
9461       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9462    }
9463    return ROK;
9464 }
9465
9466 /****************************************************************
9467  * @brief Function to process Drb Setup List
9468  *
9469  * @details
9470  *
9471  *    Function : procDrbSetupList
9472  *
9473  *    Functionality:
9474  *         - Function to process DRB Setup List
9475  *
9476  * @params[in]
9477  * @return ROK     - success
9478  *         RFAILED - failure
9479  *
9480  * ****************************************************************/
9481 uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
9482 {
9483    uint8_t arrIdx = 0, drbIdx = 0;
9484    uint32_t teId = 0;
9485    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9486
9487    if(drbSetupList != NULLP)
9488    {
9489       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9490       {
9491          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9492          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9493          {
9494             /* extracting teId */
9495             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9496             if(teId > 0)
9497             {
9498                if(addDrbTunnels(duId, teId)== ROK)
9499                {
9500                   DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9501                }
9502                /* As per Spec 38.473, in UE COntext Response, Tunnel information
9503                 * are sent to CU for setting up of Tunnels in DL direction.
9504                 * Search for DRB ID in CU databse */
9505                for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
9506                {
9507                   if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
9508                   {
9509                      fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
9510                      break;
9511                   }
9512                }
9513             }
9514             else
9515                return RFAILED;
9516          }
9517       }
9518    }
9519    return ROK;
9520 }
9521
9522 /****************************************************************
9523  * @brief Function to process Ue Context Setup Response
9524  *
9525  * @details
9526  *
9527  *    Function : procUeContextSetupResponse
9528  *
9529  *    Functionality:
9530  *         - Function to process Ue Context Setup Response
9531  *
9532  * @params[in]
9533  * @return ROK     - success
9534  *         RFAILED - failure
9535  *
9536  * ****************************************************************/
9537 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9538 {
9539    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9540    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9541    DuDb *duDb = NULLP;
9542    CuUeCb *ueCb = NULLP;
9543    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9544    OCTET_STRING_t *duToCuRrcContainer;
9545
9546    SEARCH_DU_DB(duIdx, duId, duDb);
9547    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9548
9549    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9550    {
9551       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9552       {
9553           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9554              {
9555                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9556                break;
9557              }
9558           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9559              {
9560                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9561                 ueCb = &duDb->ueCb[duUeF1apId-1];
9562                 /* If ue context is not present in du db, then create UE context
9563                  * here. This flow is hit in case of UE handover where UE
9564                  * context is created before UE performs RACH on target DU */
9565                 if(ueCb->gnbDuUeF1apId == 0)
9566                 {
9567                    /* Creating UE context in target DU */
9568                    memset(ueCb, 0, sizeof(CuUeCb));
9569                    ueCb->cellCb = &duDb->cellCb[0];
9570                    ueCb->gnbDuUeF1apId = duUeF1apId;
9571                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9572                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9573                    ueCb->hoInfo.targetDuId = duId;
9574                    (duDb->numUe)++;
9575
9576                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9577                    ueCb->cellCb->numUe++;
9578                 }
9579                 break;
9580              }
9581           case ProtocolIE_ID_id_C_RNTI:
9582              {
9583                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9584                 break;
9585              }
9586           case ProtocolIE_ID_id_DRBs_Setup_List:
9587              {
9588                 /* Adding Tunnels for successful DRB */
9589                 procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9590                 break;
9591              }
9592          case ProtocolIE_ID_id_DUtoCURRCInformation:
9593              {
9594                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9595                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9596                    DUtoCURRCInformation.cellGroupConfig;
9597                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9598                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9599                 {
9600                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9601                    return RFAILED;
9602                 }
9603                 break;
9604              }
9605       }
9606    }
9607
9608    /* If the UE is in handover, UE context modification request is to be sent to
9609     * source DU once UE context setup response is received from target DU */
9610    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9611    {
9612       DuDb *srcDuDb = NULLP;
9613       CuUeCb *ueCbInSrcDu = NULLP;
9614
9615       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9616        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9617       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9618       {
9619          /* UE context setup response is received from target DU. Search all
9620           * DUs to find source DU except this target DU Id.*/
9621          if(cuCb.duInfo[duIdx].duId != duId)
9622          {
9623             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9624             {
9625                /* Check following:
9626                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9627                 * received in UE context setup response since CU UE F1AP ID does not
9628                 * change for UE in handover.
9629                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9630                 */
9631                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9632                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9633                {
9634                   srcDuDb = &cuCb.duInfo[duIdx];
9635                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9636
9637                   /* Store source DU info in the new UE context created in
9638                    * tareget DU */
9639                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9640
9641                   /* Copy the received container to UeCb */
9642                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9643
9644                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9645                   {
9646                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9647                      return RFAILED;
9648                   }
9649                   break;
9650                }
9651             }
9652          }
9653          if(srcDuDb && ueCbInSrcDu)
9654             break;
9655       }
9656    }
9657    else
9658    {
9659       ueCb->f1apMsgDb.dlRrcMsgCount++;
9660       rrcMsgType = setDlRRCMsgType(ueCb);
9661
9662       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9663       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9664       {
9665          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9666          return RFAILED;
9667       }
9668    }
9669
9670    return ROK;
9671 }
9672
9673 /****************************************************************
9674  * @brief Function to process Ul Rrc Msg received from DU
9675  *
9676  * @details
9677  *
9678  *    Function : procUlRrcMsg
9679  *
9680  *    Functionality:
9681  *         - Function to process Ul Rrc Msg received from DU
9682  *
9683  * @params[in]
9684  * @return ROK     - success
9685  *         RFAILED - failure
9686  *
9687  * ****************************************************************/
9688
9689 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9690 {
9691    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9692    uint8_t  *rrcContainer = NULLP;
9693    uint16_t rrcContLen = 0;
9694    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9695    DuDb     *duDb = NULLP;
9696    CuUeCb   *ueCb = NULLP;
9697    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9698
9699    ret = ROK;
9700    SEARCH_DU_DB(duIdx, duId, duDb);
9701    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9702
9703    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9704    {
9705       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9706       {
9707          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9708             {
9709                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9710                break;
9711             }
9712          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9713             {
9714                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9715                break;
9716             }
9717          case ProtocolIE_ID_id_SRBID:
9718             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9719             break;
9720
9721          case ProtocolIE_ID_id_RRCContainer:
9722             {
9723                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9724                CU_ALLOC(rrcContainer, rrcContLen);
9725                if(!rrcContainer)
9726                {
9727                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9728                   return RFAILED;
9729                }
9730                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9731
9732                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9733                {
9734                   uint8_t ueIdx = 0;
9735                   uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.sourceDuId;
9736                   DuDb *srcDuDb = NULLP;
9737
9738                   /* In target DU DB, mark UE as active and delete HO info */
9739                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9740                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9741
9742                   /* Release UE context in source DU because the UE is now
9743                    * attached to target DU */
9744                   SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9745                   for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9746                   {
9747                      if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9748                      {
9749                         ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9750                         if(ret != ROK)
9751                         {
9752                            DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9753                         }
9754                         break;
9755                      }
9756                   }
9757                   return ret;
9758                }
9759                break;
9760             }
9761
9762          default:
9763             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9764             break;
9765       }
9766    }
9767
9768    if(srbId == 1)
9769    {
9770       ueCb = &duDb->ueCb[duUeF1apId-1];
9771       ueCb->f1apMsgDb.dlRrcMsgCount++;
9772       rrcMsgType = setDlRRCMsgType(ueCb);
9773       if(rrcMsgType == RRC_SETUP_COMPLETE)
9774       {
9775          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for Security Mode Command");
9776          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9777       }
9778       else if(rrcMsgType == SECURITY_MODE_COMPLETE)
9779       {
9780          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9781          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9782       }
9783       else if(rrcMsgType == REGISTRATION_COMPLETE)
9784       {
9785          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9786          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9787       }
9788       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9789       {
9790          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9791          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9792       }
9793    }
9794    return ret;
9795 }
9796
9797 /****************************************************************
9798  * @brief Build And Send F1ResetAck
9799  *
9800  * @details
9801  *
9802  *    Function : FreeF1ResetAck
9803  *
9804  *    Functionality:
9805  *         - Build And Send  F1ResetRSP
9806  *
9807  *  @params[in]
9808  * @return ROK     - success
9809  *         RFAILED - failure
9810  *
9811  * ****************************************************************/
9812 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9813 {
9814    uint8_t idx;
9815    ResetAcknowledge_t *f1ResetAck;
9816
9817    if(f1apMsg)
9818    {
9819       if(f1apMsg->choice.successfulOutcome)
9820       {
9821          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9822
9823          if(f1ResetAck->protocolIEs.list.array)
9824          {
9825             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9826             {
9827                if(f1ResetAck->protocolIEs.list.array[idx])
9828                {
9829                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9830                }
9831             }
9832             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9833          }
9834          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9835       }
9836       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9837    }
9838 }
9839
9840 /****************************************************************
9841  * @brief Build And Send F1ResetAck
9842  *
9843  * @details
9844  *
9845  *    Function : BuildAndSendF1ResetAck
9846  *
9847  *    Functionality:
9848  *         - Build And Send  F1ResetRSP
9849  *
9850  *  @params[in]
9851  * @return ROK     - success
9852  *         RFAILED - failure
9853  *
9854  * ****************************************************************/
9855
9856 uint8_t BuildAndSendF1ResetAck()
9857 {
9858    uint8_t                idx = 0;
9859    uint8_t                elementCnt = 0;
9860    uint8_t                ret = RFAILED;
9861    F1AP_PDU_t             *f1apMsg = NULL;
9862    ResetAcknowledge_t     *f1ResetAck = NULLP;
9863    asn_enc_rval_t         encRetVal;
9864    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9865
9866    do{
9867       /* Allocate the memory for F1ResetRequest_t */
9868       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9869       if(f1apMsg == NULLP)
9870       {
9871          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9872          break;
9873       }
9874
9875       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9876
9877       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9878       if(f1apMsg->choice.successfulOutcome == NULLP)
9879       {
9880          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9881          break;
9882       }
9883
9884       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9885       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9886       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9887       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9888
9889       elementCnt = 1;
9890
9891       f1ResetAck->protocolIEs.list.count = elementCnt;
9892       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9893
9894       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9895       if(f1ResetAck->protocolIEs.list.array == NULLP)
9896       {
9897          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9898          break;
9899       }
9900
9901       for(idx=0; idx<elementCnt; idx++)
9902       {
9903          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9904          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9905          {
9906             break;
9907          }
9908       }
9909       /*TransactionID*/
9910       idx = 0;
9911       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9912       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9913       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9914       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9915
9916       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9917
9918       /* Encode the F1SetupRequest type as UPER */
9919       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9920       encBufSize = 0;
9921       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9922
9923       /* Check encode results */
9924       if(encRetVal.encoded == ENCODE_FAIL)
9925       {
9926          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9927                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9928          break;
9929       }
9930       else
9931       {
9932          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9933          for(int i=0; i< encBufSize; i++)
9934          {
9935             DU_LOG("%x",encBuf[i]);
9936          }
9937       }
9938
9939       /* Sending msg */
9940       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9941       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9942       {
9943          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9944          break;
9945       }
9946
9947       ret = ROK;
9948       break;
9949    }while(true);
9950
9951    FreeF1ResetAck(f1apMsg);
9952    return ret;
9953 }
9954
9955 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9956 {
9957    uint8_t arrIdx =0;
9958
9959    if(ulInfo->list.array)
9960    {
9961       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9962       {
9963          if(ulInfo->list.array[arrIdx])
9964          {
9965             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9966             {
9967                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9968                {
9969                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9970                   {
9971                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9972                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9973                      gTPTunnel->gTP_TEID.size);
9974                   }
9975                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9976                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9977                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9978                }
9979                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9980                sizeof(GTPTunnel_t));
9981             }
9982             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9983          }
9984       }
9985       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9986    }
9987 }
9988
9989 /*******************************************************************
9990 *
9991 * @brief Deletes the EGTP tunnel
9992 *
9993 * @details
9994 *
9995 *    Function : deleteEgtpTunnel
9996 *
9997 *    Functionality: Deletes the EGTP tunnel
9998 *
9999 * @params[in] uint8_t *buf
10000 *
10001 * @return ROK     - success
10002 *         RFAILED - failure
10003 *
10004 * ****************************************************************/
10005 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
10006 {
10007    uint32_t teId = 0;
10008    EgtpTnlEvt tnlEvt;
10009
10010    teIdStringToInt(buf, &teId);
10011    if(teId > MAX_TEID || teId < MIN_TEID)
10012    {
10013       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
10014       return RFAILED;
10015    }
10016    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
10017    tnlEvt.action = EGTP_TNL_MGMT_DEL;
10018    tnlEvt.lclTeid = teId;
10019    tnlEvt.remTeid = teId;
10020    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
10021    {
10022       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
10023    }
10024    return ROK;
10025 }
10026
10027 /*******************************************************************
10028 *
10029 * @brief Builds the Uplink Tunnel Info
10030 *
10031 * @details
10032 *
10033 *    Function : BuildUlTnlInfoforSetupMod
10034 *
10035 *    Functionality: Constructs the UL TnlInfo For DRB list
10036 *
10037 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10038 *
10039 * @return ROK     - success
10040 *         RFAILED - failure
10041 *
10042 * ****************************************************************/
10043 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
10044 {
10045    uint8_t arrIdx;
10046    uint8_t ulCnt;
10047
10048    ulCnt = 1;
10049    ulInfo->list.count = ulCnt;
10050    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
10051    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
10052    if(ulInfo->list.array == NULLP)
10053    {
10054       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10055       return RFAILED;
10056    }
10057    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
10058    {
10059       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10060       if(ulInfo->list.array[arrIdx] == NULLP)
10061       {
10062          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10063          return RFAILED;
10064       }
10065    }
10066
10067    arrIdx = 0;
10068    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
10069    UPTransportLayerInformation_PR_gTPTunnel;
10070
10071    /*GTP TUNNEL*/
10072    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10073          sizeof(GTPTunnel_t));
10074    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
10075    {
10076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10077       return RFAILED;
10078    }
10079    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10080       transportLayerAddress.size        = 4*sizeof(uint8_t);
10081    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10082          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10083          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10084    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10085          transportLayerAddress.buf == NULLP)
10086    {
10087       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10088       return RFAILED;
10089    }
10090
10091    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10092       transportLayerAddress.buf[0] = 192;
10093    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10094       transportLayerAddress.buf[1] = 168;
10095    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10096       transportLayerAddress.buf[2] = 130;
10097    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10098       transportLayerAddress.buf[3] = 82;
10099    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10100       transportLayerAddress.bits_unused = 0;
10101
10102    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
10103    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
10104    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
10105    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
10106
10107    /*GTP TEID*/
10108    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
10109       = 4 * sizeof(uint8_t);
10110    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10111          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10112          gTPTunnel->gTP_TEID.size);
10113    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10114          == NULLP)
10115    {
10116       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10117       return RFAILED;
10118    }
10119    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10120       gTP_TEID.buf[0] = 0;
10121    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10122       gTP_TEID.buf[1] = 0;
10123    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10124       gTP_TEID.buf[2] = 0;
10125    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
10126    {
10127      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
10128       * fetched based on the Drb Id */
10129
10130      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
10131       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
10132                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
10133    }
10134    else
10135    {
10136       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10137         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
10138    }
10139
10140    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
10141    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
10142    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
10143    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
10144    return ROK;
10145 }/*End of BuildULTnlInfo*/
10146
10147 /*******************************************************************
10148 *
10149 * @brief freeing the DRB item
10150 *
10151 * @details
10152 *
10153 *    Function : FreeDrbItem
10154 *
10155 *    Functionality: freeing the DRB item
10156 *
10157 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10158 *
10159 * @return ROK     - success
10160 *         RFAILED - failure
10161 *
10162 * ****************************************************************/
10163
10164 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
10165 {
10166    uint8_t arrIdx =0;
10167    SNSSAI_t *snssai =NULLP;
10168    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10169
10170    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10171    switch(drbItem->qoSInformation.present)
10172    {
10173       case QoSInformation_PR_NOTHING:
10174          break;
10175       case QoSInformation_PR_eUTRANQoS:
10176          {
10177             if(drbItem->qoSInformation.choice.eUTRANQoS)
10178             {
10179                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10180             }
10181             break;
10182          }
10183       case QoSInformation_PR_choice_extension:
10184          {
10185             if(drbItem->qoSInformation.choice.choice_extension)
10186             {
10187                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10188
10189                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10190                if(snssai->sST.buf)
10191                {
10192                   CU_FREE(snssai->sST.buf,snssai->sST.size);
10193                }
10194                if(snssai->sD)
10195                {
10196                   if(snssai->sD->buf)
10197                   {
10198                      CU_FREE(snssai->sD->buf,snssai->sD->size);
10199                   }
10200                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10201                }
10202
10203                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10204                if(flowMap->list.array)
10205                {
10206                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10207                   {
10208                      if(flowMap->list.array[arrIdx] )
10209                      {
10210                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10211                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10212                      }
10213                   }
10214                   CU_FREE(flowMap->list.array,flowMap->list.size);
10215                }
10216
10217                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10218             }
10219             break;
10220          }
10221
10222    }
10223    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10224    if(drbItem->uLConfiguration)
10225    {
10226       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10227    }
10228 }
10229
10230 /*******************************************************************
10231 *
10232 * @brief filling the DRB setup Mod item
10233 *
10234 * @details
10235 *
10236 *    Function : FillDrbItemToSetupMod
10237 *
10238 *    Functionality: filling the DRB setup Mod item
10239 *
10240 *
10241 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10242 *
10243 * @return ROK     - success
10244 *         RFAILED - failure
10245 *
10246 * ****************************************************************/
10247
10248 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
10249 {
10250    uint8_t ret = ROK;
10251
10252    /*Drb Id */
10253    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
10254    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
10255
10256    /*qoSInformation*/
10257    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10258
10259    switch(drbItem->qoSInformation.present)
10260    {
10261       case QoSInformation_PR_NOTHING:
10262       {
10263          break;
10264       }
10265       case QoSInformation_PR_eUTRANQoS:
10266       {
10267
10268          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10269          if(drbItem->qoSInformation.choice.eUTRANQoS)
10270          {
10271             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10272             return RFAILED;
10273          }
10274          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10275          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10276             PriorityLevel_no_priority;
10277
10278          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10279             Pre_emptionCapability_may_trigger_pre_emption;
10280
10281          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10282             Pre_emptionVulnerability_pre_emptable;
10283
10284          break;
10285       }
10286       case QoSInformation_PR_choice_extension:
10287       {
10288          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10289          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10290          {
10291             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10292             return RFAILED;
10293          }
10294
10295          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10296          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10297          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10298          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10299            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10300          if(ret != ROK)
10301          {
10302             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10303             return RFAILED;
10304          }
10305
10306          /*SNSSAI*/
10307          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10308                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10309          if(ret != ROK)
10310          {
10311             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10312             return RFAILED;
10313          }
10314
10315          /*Flows mapped to DRB List*/
10316          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10317                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10318           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10319          if(ret != ROK)
10320          {
10321             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10322             return RFAILED;
10323          }
10324       }
10325    }
10326
10327    /*ULUPTNLInformation To Be Setup List*/
10328    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10329       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10330    if(ret != ROK)
10331    {
10332       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10333       return RFAILED;
10334    }
10335
10336    /*RLCMode*/
10337    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10338    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10339
10340    ueCb->numDrb++;
10341    return ROK;
10342 }
10343
10344 /*******************************************************************
10345 *
10346 * @brief Builds the DRB to be Setup Mod ItemIes
10347 *
10348 * @details
10349 *
10350 *    Function : FillDrbItemList
10351 *
10352 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10353 *
10354 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10355 *
10356 * @return ROK     - success
10357 *         RFAILED - failure
10358 *
10359 * ****************************************************************/
10360
10361 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10362 {
10363    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10364    drbItemIe->criticality = Criticality_reject;
10365    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10366
10367    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10368    {
10369       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10370       return RFAILED;
10371    }
10372    return ROK;
10373 }
10374 /*******************************************************************
10375 *
10376 * @brief free the DRB to be Setup Mod list
10377 *
10378 * @details
10379 *
10380 *    Function : FreeDrbToBeSetupModList
10381 *
10382 *    Functionality: free the DRB to be Setup Mod list
10383 *
10384 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10385 *
10386 * @return ROK     - success
10387 *         RFAILED - failure
10388 *
10389 * ****************************************************************/
10390 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10391 {
10392    uint8_t arrIdx =0;
10393    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10394
10395    if(drbSet->list.array)
10396    {
10397       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10398       {
10399          if(drbSet->list.array[arrIdx] != NULLP)
10400          {
10401             if(arrIdx == 0)
10402             {
10403                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10404                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10405             }
10406             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10407          }
10408       }
10409       CU_FREE(drbSet->list.array, drbSet->list.size);
10410    }
10411
10412 }
10413
10414 /*******************************************************************
10415 *
10416 * @brief Builds the DRB to be Setup Mod list
10417 *
10418 * @details
10419 *
10420 *    Function : BuildDrbToBeSetupList
10421 *
10422 *    Functionality: Constructs the DRB to be Setup Mod list
10423 *
10424 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10425 *
10426 * @return ROK     - success
10427 *         RFAILED - failure
10428 *
10429 * ****************************************************************/
10430
10431 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10432 {
10433    uint8_t ret = ROK;
10434    uint8_t arrIdx =0;
10435    uint8_t drbCnt =0;
10436
10437    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10438    drbSet->list.count = drbCnt;
10439    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10440    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10441    if(drbSet->list.array == NULLP)
10442    {
10443       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10444       return  RFAILED;
10445    }
10446
10447    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10448    {
10449       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10450       if(drbSet->list.array[arrIdx] == NULLP)
10451       {
10452          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10453          return  RFAILED;
10454       }
10455
10456       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10457       if(ret != ROK)
10458       {
10459          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10460       }
10461    }
10462
10463    return ret;
10464 }
10465
10466 /*******************************************************************
10467 *
10468 * @brief Filling the DRB to be modified item
10469 *
10470 * @details
10471 *
10472 *    Function : FillDrbToBeModItem
10473 *
10474 *    Functionality: filling the DRB to be modified item
10475 *
10476 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10477 *
10478 * @return ROK     - success
10479 *         RFAILED - failure
10480 *
10481 * ****************************************************************/
10482
10483 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10484 {
10485    uint8_t ret = ROK;
10486    uint drbIdx=0;
10487    DrbInfo *drbToBeMod;
10488
10489    /*Drb Id */
10490    drbItem->dRBID = DRB2 + arrIdx;
10491
10492    /* Search for DRB ID in CU databse */
10493    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10494    {
10495       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10496       {
10497          drbToBeMod = &ueCb->drbList[drbIdx];
10498          break;
10499       }
10500    }
10501
10502    /*qoSInformation*/
10503    drbItem->qoSInformation = NULLP;
10504    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10505    if(drbItem->qoSInformation != NULLP)
10506    {
10507       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10508
10509       switch(drbItem->qoSInformation->present)
10510       {
10511          case QoSInformation_PR_NOTHING:
10512             {
10513                break;
10514             }
10515          case QoSInformation_PR_eUTRANQoS:
10516             {
10517
10518                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10519                if(drbItem->qoSInformation->choice.eUTRANQoS)
10520                {
10521                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10522                   return RFAILED;
10523                }
10524                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10525                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10526                   PriorityLevel_no_priority;
10527
10528                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10529                   Pre_emptionCapability_may_trigger_pre_emption;
10530
10531                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10532                   Pre_emptionVulnerability_pre_emptable;
10533
10534                break;
10535             }
10536          case QoSInformation_PR_choice_extension:
10537             {
10538                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10539                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10540                {
10541                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10542                   return RFAILED;
10543                }
10544
10545                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10546                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10547                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10548                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10549                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10550                if(ret != ROK)
10551                {
10552                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10553                   return RFAILED;
10554                }
10555
10556                /*SNSSAI*/
10557                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10558                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10559                if(ret != ROK)
10560                {
10561                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10562                   return RFAILED;
10563                }
10564
10565                /*Flows mapped to DRB List*/
10566                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10567                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10568                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10569                if(ret != ROK)
10570                {
10571                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10572                   return RFAILED;
10573                }
10574             }
10575       }
10576    }/* End of QoS */
10577
10578    /*ULUPTNLInformation To Be Setup List*/
10579    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10580             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10581    if(ret != ROK)
10582    {
10583       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10584       return RFAILED;
10585    }
10586    return ROK;
10587 }
10588
10589 /*******************************************************************
10590 *
10591 * @brief Builds the DRB to be modified Item IE
10592 *
10593 * @details
10594 *
10595 *    Function : FillDrbToBeModItemList
10596 *
10597 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10598 *
10599 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10600 *
10601 * @return ROK     - success
10602 *         RFAILED - failure
10603 *
10604 * ****************************************************************/
10605
10606 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10607 {
10608    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10609    drbItemIe->criticality = Criticality_reject;
10610    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10611    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10612    {
10613       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10614       return RFAILED;
10615    }
10616
10617    return ROK;
10618 }
10619
10620 /*******************************************************************
10621 *
10622 * @brief Builds the DRB to be modified list
10623 *
10624 * @details
10625 *
10626 *    Function : BuildDrbToBeModList
10627 *
10628 *    Functionality: Constructs the DRB to be modified list
10629 *
10630 * @params[in] DRBs_ToBeModified_List_t *drbSet
10631 *
10632 * @return ROK     - success
10633 *         RFAILED - failure
10634 *
10635 * ****************************************************************/
10636
10637 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10638 {
10639    uint8_t ret = ROK;
10640    uint8_t arrIdx =0;
10641    uint8_t drbCnt =0;
10642
10643    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10644    drbSet->list.count = drbCnt;
10645    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10646    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10647    if(drbSet->list.array == NULLP)
10648    {
10649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10650       return  RFAILED;
10651    }
10652    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10653    {
10654       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10655       if(drbSet->list.array[arrIdx] == NULLP)
10656       {
10657          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10658          return  RFAILED;
10659       }
10660
10661       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10662       if(ret != ROK)
10663       {
10664          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10665       }
10666    }
10667
10668    return ret;
10669 }
10670
10671 /*******************************************************************
10672 *
10673 * @brief freeing the DRB  item
10674 *
10675 * @details
10676 *
10677 *    Function : FreeModifiedDrbItem
10678 *
10679 *    Functionality: freeing the DRB 2 item
10680 *
10681 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10682 *
10683 * @return ROK     - success
10684 *         RFAILED - failure
10685 *
10686 * ****************************************************************/
10687
10688 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10689 {
10690    uint8_t arrIdx =0;
10691    SNSSAI_t *snssai =NULLP;
10692    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10693
10694    if(drbItem->qoSInformation != NULLP)
10695    {
10696       switch(drbItem->qoSInformation->present)
10697       {
10698          case QoSInformation_PR_NOTHING:
10699             break;
10700          case QoSInformation_PR_eUTRANQoS:
10701             {
10702                if(drbItem->qoSInformation->choice.eUTRANQoS)
10703                {
10704                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10705                }
10706                break;
10707             }
10708          case QoSInformation_PR_choice_extension:
10709             {
10710                if(drbItem->qoSInformation->choice.choice_extension)
10711                {
10712                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10713
10714                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10715                   if(snssai->sST.buf)
10716                   {
10717                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10718                   }
10719                   if(snssai->sD)
10720                   {
10721                      if(snssai->sD->buf)
10722                      {
10723                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10724                      }
10725                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10726                   }
10727
10728                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10729                   if(flowMap->list.array)
10730                   {
10731                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10732                      {
10733                         if(flowMap->list.array[arrIdx] )
10734                         {
10735                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10736                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10737                         }
10738                      }
10739                      CU_FREE(flowMap->list.array,flowMap->list.size);
10740                   }
10741
10742                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10743                }
10744                break;
10745             }
10746       }
10747    }
10748    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10749    if(drbItem->uLConfiguration)
10750    {
10751       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10752    }
10753 }
10754
10755 /*******************************************************************
10756 *
10757 * @brief free the DRB to be modfified list
10758 *
10759 * @details
10760 *
10761 *    Function : FreeDrbToBeModifiedList
10762 *
10763 *    Functionality: free the DRB to be Setup Mod list
10764 *
10765 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10766 *
10767 * @return ROK     - success
10768 *         RFAILED - failure
10769 *
10770 * ****************************************************************/
10771 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10772 {
10773    uint8_t arrIdx =0;
10774    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10775
10776    if(drbSet->list.array)
10777    {
10778       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10779       {
10780          if(drbSet->list.array[arrIdx] != NULLP)
10781          {
10782             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10783             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10784             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10785          }
10786       }
10787       CU_FREE(drbSet->list.array, drbSet->list.size);
10788    }
10789
10790 }
10791
10792 /*******************************************************************
10793  *
10794  * @brief  free the UeContextModification Request
10795  *
10796  * @details
10797  *
10798  *    Function : FreeUeContextModicationRequest
10799  *
10800  *    Functionality : deallocation of memory allocated in UeContextModiification
10801  request
10802  *
10803  * @params[in] F1AP_PDU_t *f1apMsg
10804  *
10805  * @return void
10806 *
10807 * ****************************************************************/
10808 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10809 {
10810    uint8_t arrIdx =0 , ieId=0;
10811    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10812
10813    if(f1apMsg)
10814    {
10815       if(f1apMsg->choice.initiatingMessage)
10816       {
10817          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10818          if(ueContextModifyReq->protocolIEs.list.array)
10819          {
10820             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10821             {
10822                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10823                {
10824                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10825                   switch(ieId)
10826                   {
10827                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10828                         break;
10829                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10830                         break;
10831                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10832                         {
10833                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10834                                  choice.DRBs_ToBeSetupMod_List);
10835                            break;
10836                         }
10837                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10838                         {
10839                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10840                                  choice.DRBs_ToBeModified_List);
10841                            break;
10842                         }
10843                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10844                         break;
10845                     case ProtocolIE_ID_id_RRCContainer:
10846                     {
10847                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10848                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10849                     }
10850
10851                   }
10852                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10853                }
10854             }
10855             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10856          }
10857          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10858       }
10859       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10860    }
10861 }
10862
10863 /*******************************************************************
10864  *
10865  * @brief Builds the Ue Context Modification Req
10866  *
10867  * @details
10868  *
10869  *    Function : BuildAndSendUeContextModificationReq
10870  *
10871  *    Functionality: Constructs the Ue Context Modification Req
10872  *
10873  * @params[in]
10874  *
10875  * @return ROK     - success
10876  *         RFAILED - failure
10877  *
10878  * ****************************************************************/
10879 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10880 {
10881    uint8_t    ieIdx = 0;
10882    uint8_t    elementCnt = 0;
10883    uint8_t    ret = RFAILED;
10884    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10885    F1AP_PDU_t *f1apMsg = NULLP;
10886    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10887    asn_enc_rval_t         encRetVal;
10888    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10889    while(1)
10890    {
10891       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10892       if(f1apMsg == NULLP)
10893       {
10894          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10895          break;
10896       }
10897
10898       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10899
10900       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10901       if(f1apMsg->choice.initiatingMessage == NULLP)
10902       {
10903          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10904          break;
10905       }
10906       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10907       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10908       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10909
10910       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10911
10912       if(action == MODIFY_UE)
10913          elementCnt = 4;
10914       else if(action == QUERY_CONFIG)
10915          elementCnt = 3;
10916       else if(action == RRC_RECONFIG_COMPLETE_IND)
10917          elementCnt = 3;
10918       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10919          elementCnt = 5;
10920
10921       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10922       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10923
10924       /* Initialize the UE context modification members */
10925       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10926       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10927       {
10928          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10929          break;
10930       }
10931
10932       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10933       {
10934          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10935          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10936          {
10937             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10938             break;
10939          }
10940       }
10941
10942       ieIdx=0;
10943       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10944       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10945       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10946                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10947       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10948
10949       ieIdx++;
10950       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10951       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10952       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10953                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10954       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10955
10956       if(action == MODIFY_UE)
10957       {
10958          /* DRB to be setup list */
10959          ieIdx++;
10960          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10961          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10962          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10963                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10964          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10965                   value.choice.DRBs_ToBeSetupMod_List));
10966
10967          /* DRB to be modified list */
10968          ieIdx++;
10969          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10970          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10971          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10972                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10973          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10974                   value.choice.DRBs_ToBeModified_List));
10975
10976          /* TODO: DRB to be release list */
10977
10978          if(ret != ROK)
10979          {
10980             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
10981             break;
10982          }
10983
10984          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
10985       }
10986       else if(action == QUERY_CONFIG)
10987       {
10988          ieIdx++;
10989          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10990          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10991          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10992             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10993          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10994       }
10995       else if(action == RRC_RECONFIG_COMPLETE_IND)
10996       {
10997          ieIdx++;
10998          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10999          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11000          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11001             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
11002          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
11003             RRCReconfigurationCompleteIndicator_true;
11004       }
11005       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11006       {
11007          ieIdx++;
11008          if(action == STOP_DATA_TX)
11009          {
11010             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11011             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11012             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11013             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11014             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11015             TransmissionActionIndicator_stop;
11016          }
11017          else if (action == RESTART_DATA_TX)
11018          {
11019             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11020             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11021             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11022             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11023             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11024             TransmissionActionIndicator_restart;
11025          }
11026
11027          ieIdx++;
11028          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11029          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11030          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11031          UEContextModificationRequestIEs__value_PR_RRCContainer;
11032          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
11033          {
11034             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
11035             return RFAILED;
11036          }
11037
11038          /* RRC delivery status request */
11039          ieIdx++;
11040          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
11041          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11042          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
11043          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
11044       }
11045
11046       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11047
11048       /* Encode the F1SetupRequest type as APER */
11049       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11050       encBufSize = 0;
11051       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11052
11053       /* Encode results */
11054       if(encRetVal.encoded == ENCODE_FAIL)
11055       {
11056          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
11057                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11058          break;
11059       }
11060       else
11061       {
11062          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
11063 #if 0
11064          /* This for loop was going into an infinite loop even though encBufSize
11065           * has a small value. Hence commented this
11066           */
11067          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11068          {
11069             DU_LOG("%x",encBuf[ieIdx]);
11070          }
11071 #endif
11072       }
11073
11074       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11075       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11076       {
11077          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
11078          break;
11079       }
11080
11081       ret = ROK;
11082       break;
11083
11084    }
11085    FreeUeContextModicationRequest(f1apMsg);
11086    return ret;
11087 }
11088
11089 /*****************************************************************i
11090  *
11091 * @brief Free memory allocated for UE Context Release Command
11092 *
11093 * @details
11094 *
11095 *    Function : FreeUeContextReleaseCommand
11096 *
11097 *    Functionality:
11098 *         - Free memory allocated for UE Context Release Command
11099 *
11100 * @params[in] F1AP_PDU_t *f1apMsg
11101 * @return void
11102 *
11103 * *************************************************************/
11104 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
11105 {
11106    uint8_t ieIdx;
11107    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
11108
11109    if(f1apMsg)
11110    {
11111       if(f1apMsg->choice.initiatingMessage)
11112       {
11113          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11114          if(ueReleaseCommand->protocolIEs.list.array)
11115          {
11116             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
11117             {
11118                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11119             }
11120             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
11121          }
11122          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11123       }
11124       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11125    }
11126 }
11127 /*******************************************************************
11128  *
11129  * @brief Builds the Ue Context Release Command
11130  *
11131  * @details
11132 *
11133 *    Function : BuildAndSendUeContextReleaseCommand
11134 *
11135 *    Functionality: Constructs the Ue Context Release Command
11136 *
11137 * @params[in]
11138 *
11139 * @return ROK     - success
11140 *         RFAILED - failure
11141 *
11142 * ****************************************************************/
11143 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
11144 {
11145    bool       memAllocFailed = false;
11146    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
11147    DuDb *duDb;
11148    CuUeCb *ueCb;
11149    F1AP_PDU_t *f1apMsg = NULLP;
11150    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
11151
11152    asn_enc_rval_t         encRetVal;
11153    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
11154
11155    while(true)
11156    {
11157       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11158       if(f1apMsg == NULLP)
11159       {
11160          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
11161          break;
11162       }
11163
11164       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11165
11166       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11167       if(f1apMsg->choice.initiatingMessage == NULLP)
11168       {
11169          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
11170          break;
11171       }
11172       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
11173       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11174       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
11175
11176       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11177
11178       SEARCH_DU_DB(duIdx, duId, duDb);
11179       ueCb = &duDb->ueCb[duUeF1apId-1];
11180       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11181          elementCnt = 3;
11182       else
11183          elementCnt = 4;
11184
11185       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
11186       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
11187
11188       /* Initialize the UE context modification members */
11189       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
11190       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
11191       {
11192          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
11193          break;
11194       }
11195
11196       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11197       {
11198          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11199          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
11200          {
11201             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
11202             memAllocFailed = true;
11203             break;
11204          }
11205       }
11206
11207       if(memAllocFailed == true)
11208       {
11209          break;
11210       }
11211
11212       ieIdx=0;
11213       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11214       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11215       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11216       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
11217       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
11218
11219       ieIdx++;
11220       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11221       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11222       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11223       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
11224       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
11225
11226       /* Cause of UE context release */
11227       ieIdx++;
11228       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
11229       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11230       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11231                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
11232       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11233       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
11234                                                                                                      CauseRadioNetwork_normal_release;
11235       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11236       {
11237          /* RRC Container for RRC release */
11238          ieIdx++;
11239          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11240          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11241          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11242                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
11243          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
11244          bufLen =7;
11245          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
11246          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
11247                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
11248          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
11249          {
11250             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
11251             break;
11252          }
11253          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
11254          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
11255       }
11256       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11257
11258       /* Encode the UE Context Release Command type as APER */
11259       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11260       encBufSize = 0;
11261       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11262             encBuf);
11263
11264       /* Encode results */
11265       if(encRetVal.encoded == ENCODE_FAIL)
11266       {
11267          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11268                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11269          break;
11270       }
11271       else
11272       {
11273          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
11274          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11275          {
11276             DU_LOG("%x",encBuf[ieIdx]);
11277          }
11278       }
11279
11280       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11281       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11282       {
11283          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11284          break;
11285       }
11286
11287       ret = ROK;
11288       break;
11289
11290    }
11291    FreeUeContextReleaseCommand(f1apMsg);
11292    return ret;
11293 }
11294 /*******************************************************************
11295 *
11296 * @brief process Ue context release request
11297 *
11298 * @details
11299 *
11300 *    Function : procUeContextReleaseReq
11301 *
11302 *    Functionality:
11303 *         - process Ue context release request
11304 *
11305 * @params[in] F1AP_PDU_t *f1apMsg
11306 * @return ROK     - success
11307 *         RFAILED - failure
11308 *
11309 * ****************************************************************/
11310 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11311 {
11312    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11313
11314    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11315    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11316
11317    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11318    {
11319       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11320       {
11321          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11322             {
11323                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11324                break;
11325             }
11326          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11327             {
11328                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11329                break;
11330             }
11331          default:
11332               break;
11333       }
11334    }
11335
11336    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11337    {
11338       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11339       return RFAILED;
11340    }
11341    return ROK;
11342 }
11343 /*******************************************************************
11344 *
11345 * @brief processing of Gnb-DU config update
11346 *
11347 * @details
11348 *
11349 *    Function : procGnbDuUpdate
11350 *
11351 *    Functionality:
11352 *         - processing of Gnb-DU config update
11353 *
11354 * @params[in] F1AP_PDU_t *f1apMsg
11355 * @return ROK     - success
11356 *         RFAILED - failure
11357 *
11358 * ****************************************************************/
11359 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11360 {
11361    bool cellToBeDelete = false;
11362    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11363    uint16_t nrCellId;
11364    DuDb *duDb;
11365    CuCellCb *cellCb;
11366    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11367
11368    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11369    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11370    {
11371       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11372       {
11373          case ProtocolIE_ID_id_TransactionID:
11374             break;
11375          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11376             break;
11377          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11378             {
11379                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11380                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11381                   Served_Cells_To_Delete_List.list.array[0];
11382                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11383                cellToBeDelete = true;
11384                break;
11385             }
11386          case ProtocolIE_ID_id_gNB_DU_ID:
11387             break;
11388       }
11389    }
11390    if(BuildAndSendDUUpdateAck(duId) != ROK)
11391    {
11392       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11393       return RFAILED;
11394    }
11395 #if 0
11396    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11397     * commented this trigger for now */
11398
11399    if(cellToBeDelete == false)
11400    {
11401       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11402       if(BuildAndSendF1ResetReq() != ROK)
11403       {
11404          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11405          return RFAILED;
11406       }
11407    }
11408 #endif
11409    if(cellToBeDelete == true)
11410    {
11411       SEARCH_DU_DB(duIdx, duId, duDb);
11412       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11413       if(cellCb->numUe == 0)
11414       {
11415          memset(cellCb, 0, sizeof(CuCellCb));
11416          duDb->numCells--;
11417       }
11418       else
11419          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11420    }
11421    return ROK;
11422 }
11423
11424 /*******************************************************************
11425 *
11426 * @brief storing slice list in CU database
11427 *
11428 * @details
11429 *
11430 *    Function : buildSliceList
11431 *
11432 *    Functionality:
11433 *         - storing slice list in CU database
11434 *
11435 * @params[in] SliceSupportList_t *sliceSupportList
11436 * @return ROK     - success
11437 *         RFAILED - failure
11438 *
11439 * ****************************************************************/
11440 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11441 {
11442    uint8_t sliceListIdx = 0;
11443
11444    if(sliceSupportList)
11445    {
11446       if(sliceSupportList->list.array)
11447       {
11448          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11449          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11450          {
11451             if(sliceSupportList->list.array[sliceListIdx])
11452             {
11453                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11454                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11455                {
11456                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11457                    return RFAILED;
11458                }
11459                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11460                {
11461                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11462                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11463                }
11464                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11465                {
11466                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11467                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11468                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11469                }
11470             }
11471          }
11472       }
11473    }
11474    return ROK;
11475 }
11476
11477 /****************************************************************
11478  * @brief Function to process Srb Setup Mod List
11479  *
11480  * @details
11481  *
11482  *    Function : procSrbSetupModList
11483  *
11484  *    Functionality:
11485  *         - Function to process SRB Setup Mod List
11486  *
11487  * @params[in]
11488  * @return ROK     - success
11489  *         RFAILED - failure
11490  *
11491  * ****************************************************************/
11492 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11493 {
11494    uint8_t arrIdx = 0, srbIdx;
11495    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11496
11497    if(srbSetupList != NULLP)
11498    {
11499       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11500       {
11501          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11502          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11503          {
11504             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11505             {
11506                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11507                {
11508                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11509                   break;
11510                }
11511             }
11512          }
11513
11514       }
11515    }
11516    return ROK;
11517 }
11518
11519
11520 /****************************************************************
11521  * @brief Function to process Drb Setup Mod List
11522  *
11523  * @details
11524  *
11525  *    Function : procDrbSetupModList
11526  *
11527  *    Functionality:
11528  *         - Function to process DRB Setup Mod List
11529  *
11530  * @params[in]
11531  * @return ROK     - success
11532  *         RFAILED - failure
11533  *
11534  * ****************************************************************/
11535 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11536 {
11537    uint8_t arrIdx = 0, drbIdx;
11538    uint32_t teId = 0;
11539    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11540
11541    if(drbSetupList != NULLP)
11542    {
11543       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11544       {
11545          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11546          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11547          {
11548             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11549             {
11550                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11551                {
11552                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11553                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11554                   break;
11555                }
11556             }
11557
11558             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11559             {
11560             /* extracting teId */
11561             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11562             if(teId > 0)
11563             {
11564               if(addDrbTunnels(duId, teId)== ROK)
11565               {
11566                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11567               }
11568             }
11569             else
11570                return RFAILED;
11571             }
11572          }
11573       }
11574    }
11575    return ROK;
11576 }
11577
11578 /*******************************************************************
11579 *
11580 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11581 *
11582 * @details
11583 *
11584 *    Function : procServedCellPlmnList
11585 *
11586 *    Functionality:
11587 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11588 *         SNSSAI list
11589 *
11590 * @params[in] F1AP_PDU_t *f1apMsg
11591 * @return ROK     - success
11592 *         RFAILED - failure
11593 *
11594 * ****************************************************************/
11595 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11596 {
11597    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11598    ProtocolExtensionContainer_4624P3_t **ieExtend;
11599
11600    if(srvPlmn->list.array)
11601    {
11602       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11603       {
11604          if(srvPlmn->list.array[srvPlmnIdx])
11605          {
11606             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11607             if(*ieExtend)
11608             {
11609                if((*ieExtend)->list.array)
11610                {
11611                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11612                   {
11613                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11614                      {
11615                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11616                         {
11617                            case ProtocolIE_ID_id_TAISliceSupportList:
11618                               {
11619                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11620                                           extensionValue.choice.SliceSupportList) != ROK)
11621                                  {
11622                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11623                                     return RFAILED;
11624                                  }
11625                               }
11626                         }
11627                      }
11628                   }
11629                }
11630             }
11631          }
11632       }
11633    }
11634    return ROK;
11635 }
11636
11637 /****************************************************************
11638  * @brief Function to process Ue Context Modification Response
11639  *
11640  * @details
11641  *
11642  *    Function : procUeContextModificationResponse
11643  *
11644  *    Functionality:
11645  *         - Function to process Ue Context Modification Response
11646  *
11647  * @params[in]
11648  * @return ROK     - success
11649  *         RFAILED - failure
11650  *
11651  * ****************************************************************/
11652 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11653 {
11654    uint8_t idx=0, duIdx=0;
11655    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11656    DuDb *duDb = NULLP;
11657    CuUeCb *ueCb = NULLP;
11658    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11659
11660    SEARCH_DU_DB(duIdx, duId, duDb);
11661    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11662
11663    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11664    {
11665       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11666       {
11667           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11668              {
11669                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11670                 break;
11671              }
11672           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11673              {
11674                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11675                 ueCb = &duDb->ueCb[duUeF1apId-1];
11676                 break;
11677              }
11678           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11679              {
11680                 /* Adding Tunnels for successful DRB */
11681                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11682                 break;
11683
11684              }
11685           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11686              {
11687                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11688                 break;
11689              }
11690          case ProtocolIE_ID_id_DUtoCURRCInformation:
11691              {
11692                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11693                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11694                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11695                 {
11696                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11697                    return RFAILED;
11698                 }
11699                 break;
11700              }
11701
11702       }
11703    }
11704
11705    /* If UE is in handover and UE context is not yet created at target DU, then send
11706     * UE context setup request to target DU */
11707    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11708    {
11709       uint8_t ueIdx = 0;
11710       DuDb *tgtDuDb = NULLP;
11711       CuUeCb *ueCbInTgtDu = NULLP;
11712
11713       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11714       if(tgtDuDb)
11715       {
11716          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11717           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11718           * DB */
11719          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11720          {
11721             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11722             {
11723                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11724                break;
11725             }
11726          }
11727
11728          /* If UE context is not found in Target DU DU, send UE context setup
11729           * request */
11730          if(ueCbInTgtDu == NULLP)
11731          {
11732             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
11733             {
11734                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11735                return RFAILED;
11736             }
11737          }
11738       }
11739    }
11740
11741    return ROK;
11742 }
11743
11744 /*******************************************************************
11745 *
11746 * @brief processing of F1 setup request
11747 *
11748 * @details
11749 *
11750 *    Function : procF1SetupReq
11751 *
11752 *    Functionality:
11753 *         - processing of  F1 setup request
11754 *
11755 * @params[in] F1AP_PDU_t *f1apMsg
11756 * @return ROK     - success
11757 *         RFAILED - failure
11758 *
11759 * ****************************************************************/
11760 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11761 {
11762    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11763    uint32_t duId = 0;
11764    uint64_t nrCellId = 0;
11765    DuDb     *duDb = NULLP;
11766    CuCellCb *cellCb = NULLP;
11767    BIT_STRING_t nrcellIdentity;
11768    F1SetupRequest_t *f1SetupReq = NULLP;
11769    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11770    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11771
11772    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11773    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11774    {
11775       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11776       {
11777          case ProtocolIE_ID_id_gNB_DU_ID:
11778            {
11779               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11780               SEARCH_DU_DB(duIdx, duId, duDb);
11781               if(duDb == NULLP)
11782               {
11783                  duDb = &cuCb.duInfo[cuCb.numDu];
11784                  cuCb.numDu++;
11785               }
11786               memset(duDb, 0, sizeof(DuDb));
11787               duDb->duId = duId;
11788               *destDuId = duId;
11789               break;
11790            }
11791          case ProtocolIE_ID_id_gNB_DU_Name:
11792            {
11793               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11794               break;
11795            }
11796          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11797            {
11798                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11799                if(duServedCell->list.array)
11800                {
11801                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11802                   {
11803                      if(duServedCell->list.array[plmnidx])
11804                      {
11805                         switch(duServedCell->list.array[plmnidx]->id)
11806                         {
11807                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11808                            {
11809                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11810                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11811                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11812
11813                               bitStringToInt(&nrcellIdentity, &nrCellId);
11814                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11815                               if(cellCb == NULLP)
11816                               {
11817                                  cellCb = &duDb->cellCb[duDb->numCells];
11818                                  memset(cellCb, 0, sizeof(CuCellCb));
11819                                  cellCb->nrCellId = nrCellId;
11820                                  cellCb->cellStatus = CELL_ACTIVE;
11821                                  duDb->numCells++;
11822                               }
11823                            }
11824                         }
11825                      }
11826                   }
11827                }
11828            }
11829       }
11830    }
11831    if(ret == ROK)
11832    {
11833       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11834    }
11835    else
11836    {
11837        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11838    }
11839 }
11840
11841 /****************************************************************
11842 *
11843 * @brief processing of UE Context Release Complete
11844 *
11845 * @details
11846 *
11847 *    Function : procUeContextReleaseComplete
11848 *
11849 *    Functionality:
11850 *         - processing of UE Context Release Complete
11851 *
11852 * @params[in] F1AP_PDU_t *f1apMsg
11853 * @return ROK     - success
11854 *         RFAILED - failure
11855 *
11856 * ****************************************************************/
11857 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11858 {
11859    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
11860    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11861    DuDb *duDb = NULLP;
11862    CuUeCb *ueCb = NULLP;
11863    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11864
11865    SEARCH_DU_DB(duIdx, duId, duDb);
11866    if(!duDb)
11867    {
11868       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11869       return;
11870    }
11871
11872    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11873    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11874    {
11875       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11876       {
11877          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11878             {
11879                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11880                break;
11881             }
11882          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11883             {
11884                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11885                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11886                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11887                {
11888                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11889                   {
11890                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11891                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11892                      {
11893                         for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11894                         {
11895                            deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
11896                         }
11897                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11898                         ueCb->cellCb->numUe--;
11899                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
11900                         {
11901                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11902                            duDb->numCells--;
11903                         }
11904                         break;
11905                      }
11906                   }
11907                }
11908                memset(ueCb, 0, sizeof(CuUeCb));
11909                duDb->numUe--;
11910                break;
11911             }
11912       }
11913    }
11914 }
11915
11916 /*******************************************************************
11917  *
11918  * @brief Builds the Paging cell list
11919  *
11920  * @details
11921  *
11922  *    Function : BuildPagingCellList
11923  *
11924  *    Functionality: Build the paging cell list
11925  *
11926  * @params[in] PagingCell_list_t  *pagingCelllist,
11927  *
11928  * @return ROK     - success
11929  *         RFAILED - failure
11930  *
11931  * ****************************************************************/
11932 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11933 {
11934    uint8_t cellIdx =0;
11935    PagingCell_ItemIEs_t *pagingCellItemIes;
11936    PagingCell_Item_t *pagingCellItem;
11937
11938    pagingCelllist->list.count = numCells;
11939    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11940    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11941    if(pagingCelllist->list.array == NULLP)
11942    {
11943       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11944       return RFAILED;
11945    }
11946
11947    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11948    {
11949       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11950       if(pagingCelllist->list.array[cellIdx] == NULLP)
11951       {
11952          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11953          return RFAILED;
11954       }
11955    }
11956
11957    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11958    {
11959       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11960       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
11961       pagingCellItemIes->criticality = Criticality_ignore;
11962       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
11963       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11964
11965       /* Fill NrCgi Information */
11966       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
11967    }
11968
11969    return ROK;
11970 }
11971
11972 /*******************************************************************
11973  *
11974  * @brief Deallocation of memory allocated in paging msg
11975  *
11976  * @details
11977  *
11978  *    Function :FreePagingMsg
11979  *
11980  *    Functionality: Deallocation of memory allocated in paging msg
11981  *
11982  * @params[in] F1AP_PDU_t *f1apMsg
11983  *
11984  * @return void
11985  *
11986  * ****************************************************************/
11987 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
11988 {
11989    uint8_t ieIdx, cellIdx;
11990    Paging_t   *paging;
11991    PagingCell_ItemIEs_t *pagingCellItemIes;
11992    PagingCell_Item_t *pagingCellItem;
11993    PagingCell_list_t  *pagingCelllist;
11994
11995    if(f1apMsg)
11996    {
11997       if(f1apMsg->choice.initiatingMessage)
11998       {
11999          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12000          if(paging->protocolIEs.list.array)
12001          {
12002             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
12003             {
12004                if(paging->protocolIEs.list.array[ieIdx])
12005                {
12006                   switch(paging->protocolIEs.list.array[ieIdx]->id)
12007                   {
12008                      case ProtocolIE_ID_id_UEIdentityIndexValue:
12009                      {
12010                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12011                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12012                         break;
12013                      }
12014
12015                      case ProtocolIE_ID_id_PagingIdentity:
12016                      {
12017                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
12018                         {
12019                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12020                            {
12021                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
12022                               {
12023                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12024                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12025                               }
12026                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
12027                                 sizeof(struct CNUEPagingIdentity));
12028                            }
12029                         }
12030                         break;
12031                      }
12032
12033                      case ProtocolIE_ID_id_PagingCell_List:
12034                      {
12035                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
12036                         if(pagingCelllist->list.array)
12037                         {
12038                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12039                            {
12040                               if(pagingCelllist->list.array[cellIdx])
12041                               {
12042                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12043                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
12044                                   {
12045                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12046                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
12047                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
12048                                   }
12049                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12050                               }
12051                            }
12052                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
12053                         }
12054                         break;
12055                      }
12056                   }
12057                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12058                }
12059             }
12060             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12061          }
12062          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12063       }
12064       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12065    }
12066 }
12067 /*******************************************************************
12068  *
12069  * @brief Builds and sends the paging message if UE is in idle mode
12070  *
12071  * @details
12072  *
12073  *    Function : BuildAndSendPagingMsg
12074  *
12075  *    Functionality: Builds and sends the paging message
12076  *
12077  * @params[in] uint32_t duId, uint8_t gsTmsi
12078  *
12079  * @return ROK     - success
12080  *         RFAILED - failure
12081  *
12082  * ****************************************************************/
12083 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
12084 {
12085    bool       memAllocFailed = false;
12086    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
12087    uint16_t   ueId = 0, duIdx = 0;
12088
12089    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
12090     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
12091    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
12092    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
12093
12094    F1AP_PDU_t *f1apMsg = NULLP;
12095    Paging_t   *paging = NULLP;
12096    DuDb       *duDb;
12097    asn_enc_rval_t         encRetVal;
12098
12099    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
12100
12101    SEARCH_DU_DB(duIdx, duId, duDb);
12102    if(duDb == NULLP)
12103    {
12104       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
12105       return ret;
12106    }
12107
12108    while(true)
12109    {
12110       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12111       if(f1apMsg == NULLP)
12112       {
12113          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
12114          break;
12115       }
12116
12117       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
12118
12119       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12120       if(f1apMsg->choice.initiatingMessage == NULLP)
12121       {
12122          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
12123          break;
12124       }
12125       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
12126       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12127       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
12128
12129       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12130
12131       elementCnt = 5;
12132       paging->protocolIEs.list.count = elementCnt;
12133       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
12134
12135       /* Initialize the Paging Message members */
12136       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12137       if(paging->protocolIEs.list.array == NULLP)
12138       {
12139          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
12140          break;
12141       }
12142
12143       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12144       {
12145          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12146          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
12147          {
12148             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12149             memAllocFailed = true;
12150             break;
12151          }
12152       }
12153
12154       if(memAllocFailed == true)
12155       {
12156          break;
12157       }
12158
12159       /* UE Identity Index Value */
12160       ieIdx=0;
12161       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
12162       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12163       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
12164       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
12165       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
12166       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12167             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12168       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
12169       {
12170          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12171          break;
12172       }
12173
12174       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
12175       ueId = gsTmsi % 1024;
12176       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
12177
12178       /* Paging Identity */
12179       ieIdx++;
12180       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
12181       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12182       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
12183       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
12184                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
12185       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
12186             sizeof(struct CNUEPagingIdentity));
12187       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12188       {
12189          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12190          break;
12191       }
12192
12193       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
12194                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
12195
12196       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
12197       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12198             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12199       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
12200       {
12201          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12202          break;
12203       }
12204
12205       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
12206             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
12207
12208       /* Paging Drx */
12209       ieIdx++;
12210       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
12211       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12212       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
12213       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
12214
12215       /* Paging Priority */
12216       ieIdx++;
12217       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
12218       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12219       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
12220       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
12221
12222       /* Paging Cell List */
12223       ieIdx++;
12224       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
12225       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12226       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
12227       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
12228       {
12229          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
12230          break;
12231       }
12232
12233       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12234
12235       /* Encode the UE Context Release Command type as APER */
12236       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12237       encBufSize = 0;
12238       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12239             encBuf);
12240
12241       /* Encode results */
12242       if(encRetVal.encoded == ENCODE_FAIL)
12243       {
12244          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
12245                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12246          break;
12247       }
12248       else
12249       {
12250          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
12251          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12252          {
12253             DU_LOG("%x",encBuf[ieIdx]);
12254          }
12255       }
12256
12257       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
12258       {
12259          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
12260          break;
12261       }
12262
12263       ret = ROK;
12264       break;
12265
12266    }
12267
12268    FreePagingMsg(f1apMsg);
12269    return ret;
12270 }
12271
12272 /*******************************************************************
12273  *
12274  * @brief Handles received F1AP message and sends back response
12275  *
12276  * @details
12277  *
12278  *    Function : F1APMsgHdlr
12279  *
12280  *    Functionality:
12281  *         - Decodes received F1AP control message
12282  *         - Prepares response message, encodes and sends to SCTP
12283  *
12284  * @params[in]
12285  * @return ROK     - success
12286  *         RFAILED - failure
12287  *
12288  * ****************************************************************/
12289 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12290 {
12291    int i;
12292    char *recvBuf;
12293    MsgLen copyCnt;
12294    MsgLen recvBufLen;
12295    F1AP_PDU_t *f1apMsg = NULLP;
12296    asn_dec_rval_t rval; /* Decoder return value */
12297    F1AP_PDU_t f1apasnmsg ;
12298
12299    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12300    ODU_PRINT_MSG(mBuf, 0,0);
12301
12302    /* Copy mBuf into char array to decode it */
12303    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12304    CU_ALLOC(recvBuf, (Size)recvBufLen);
12305
12306    if(recvBuf == NULLP)
12307    {
12308       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12309       return;
12310    }
12311    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12312    {
12313       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12314       return;
12315    }
12316
12317    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12318    for(i=0; i< recvBufLen; i++)
12319    {
12320       DU_LOG("%x",recvBuf[i]);
12321    }
12322
12323    /* Decoding flat buffer into F1AP messsage */
12324    f1apMsg = &f1apasnmsg;
12325    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12326
12327    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12328    CU_FREE(recvBuf, (Size)recvBufLen);
12329
12330    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12331    {
12332       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12333       return;
12334    }
12335    DU_LOG("\n");
12336    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12337
12338    switch(f1apMsg->present)
12339    {
12340       case F1AP_PDU_PR_initiatingMessage:
12341          {
12342             switch(f1apMsg->choice.initiatingMessage->value.present)
12343             {
12344                case InitiatingMessage__value_PR_Reset:
12345                   {
12346                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12347                      BuildAndSendF1ResetAck();
12348                      break;
12349                   }
12350
12351                case InitiatingMessage__value_PR_F1SetupRequest:
12352                   {
12353                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12354                      procF1SetupReq(duId, f1apMsg);
12355                      break;
12356                   }
12357
12358                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12359                   {
12360                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12361                      procGnbDuUpdate(*duId, f1apMsg);
12362                      break;
12363                   }
12364                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12365                   {
12366                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12367                      procInitULRRCMsg(*duId, f1apMsg);
12368                      break;
12369                   }
12370                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12371                   {
12372                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12373                      procUlRrcMsg(*duId, f1apMsg);
12374                      break;
12375                   }
12376
12377                case InitiatingMessage__value_PR_RRCDeliveryReport:
12378                   {
12379                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12380                      break;
12381                   }
12382                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12383                   {
12384                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12385                      procUeContextReleaseReq(*duId, f1apMsg);
12386                      break;
12387                   }
12388                default:
12389                   {
12390                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12391                            f1apMsg->choice.initiatingMessage->value.present);
12392                      return;
12393                   }
12394             }/* End of switch(initiatingMessage) */
12395             break;
12396          }
12397
12398       case F1AP_PDU_PR_successfulOutcome:
12399          {
12400             switch(f1apMsg->choice.successfulOutcome->value.present)
12401             {
12402                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12403                   {
12404                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12405                      break;
12406                   }
12407                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12408                   {
12409                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12410                      procUeContextSetupResponse(*duId, f1apMsg);
12411                      break;
12412                   }
12413                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12414                   {
12415                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12416                      procUeContextModificationResponse(*duId, f1apMsg);
12417                      break;
12418                   }
12419                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12420                   {
12421                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12422                       procUeContextReleaseComplete(*duId, f1apMsg);
12423                       break;
12424                   }
12425                default:
12426                   {
12427                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12428                            f1apMsg->choice.successfulOutcome->value.present);
12429                      return;
12430                   }
12431             }/* End of switch(successfulOutcome) */
12432             break;
12433          }
12434       default:
12435          {
12436             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12437             return;
12438          }
12439    }/* End of switch(f1apMsg->present) */
12440
12441 } /* End of F1APMsgHdlr */
12442
12443 /**********************************************************************
12444   End of file
12445  **********************************************************************/