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 NAS Security mode command");
1518       char secModeBuf[30]={0x00, 0x02, 0x2e, 0x82, 0xaf, 0xc0, 0x7d, 0x1c, 0x4e, 0xfc, 0x80, 0x0f, 0xc0,
1519                           0x0b, 0xa0, 0x20, 0x40, 0x9e, 0x0e, 0x1e, 0x0e, 0x1c, 0x26, 0xc0, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00};
1520       bufLen =30;
1521       rrcContainer->size = bufLen;
1522       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1523       if(rrcContainer->buf != NULLP)
1524       {
1525          memset(rrcContainer->buf, 0, bufLen);
1526          memcpy(rrcContainer->buf, secModeBuf, bufLen);
1527       }
1528       else
1529       {
1530          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1531          ret = RFAILED;
1532       }
1533    }
1534    else if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
1535    {
1536       DU_LOG("\nINFO --> F1AP : Sending RRC Security mode command");
1537       char secModeBuf[9]={0x00, 0x03, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
1538       bufLen =9;
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, secModeBuf, 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 == RRC_SECURITY_MODE_COMPLETE)
1553    {
1554       /*Hardcoded RRC Container from reference logs*/
1555       DU_LOG("\nINFO --> F1AP : Sending Registration accept");
1556       char buf[14] ={0x00, 0x04, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1557       bufLen =14;
1558       rrcContainer->size = bufLen;
1559       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1560       if(rrcContainer->buf != NULLP)
1561       {
1562          memset(rrcContainer->buf, 0, bufLen);
1563          memcpy(rrcContainer->buf, buf, bufLen);
1564       }
1565       else
1566       {
1567          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1568          ret = RFAILED;
1569       }
1570    }
1571    else if(rrcMsgType == UE_CONTEXT_SETUP_RSP)
1572    {
1573       DU_LOG("\nINFO --> F1AP : Filling DL DCCH RRC Message for RRC Reconfiguration ");
1574       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1575       if(ret == RFAILED)
1576          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1577    }
1578
1579    return ret;
1580 }
1581
1582 /*******************************************************************
1583  *
1584  * @brief Frees the DLRRCMessageTransfer
1585  *
1586  * @details
1587  *
1588  *    Function : freeDlRrcMessageTransfer
1589  *
1590  *    Functionality: Frees the DLRRCMessageTransfer
1591  *
1592  * @params[in]
1593  *
1594  * @return ROK     - success
1595  *         RFAILED - failure
1596  *
1597  * ****************************************************************/
1598 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1599 {
1600    uint8_t idx=0;
1601    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1602
1603    if(f1apMsg)
1604    {
1605       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1606       if(dlRRCMsg->protocolIEs.list.array)
1607       {
1608          idx = 3;
1609          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1610             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1611          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1612          {
1613             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1614          }
1615          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1616       }
1617       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1618    }
1619 }
1620
1621 /*******************************************************************
1622  *
1623  * @brief Builds and sends the DLRRCMessageTransfer
1624  *
1625  * @details
1626  *
1627  *    Function : BuildAndSendDLRRCMessageTransfer
1628  *
1629  *    Functionality: Constructs the DL RRC Message Transfer and sends
1630  *                   it to the CU through SCTP.
1631  *
1632  * @params[in]
1633  *
1634  * @return ROK     - success
1635  *         RFAILED - failure
1636  *
1637  * ****************************************************************/
1638 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1639 {
1640    uint8_t   elementCnt = 0;
1641    uint8_t  ieId;
1642    uint8_t  idx;
1643    F1AP_PDU_t  *f1apMsg = NULLP;
1644    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1645    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1646
1647    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1648
1649    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1650    if(f1apMsg == NULLP)
1651    {
1652       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1653       return RFAILED;
1654    }
1655
1656    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1657    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1658    if(f1apMsg->choice.initiatingMessage == NULLP)
1659    {
1660       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1661       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1662       return RFAILED;
1663    }
1664
1665    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1666    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1667    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1668    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1669
1670    elementCnt = 4;
1671    dlRRCMsg->protocolIEs.list.count = elementCnt;
1672    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1673
1674    /* Initialize the F1Setup members */
1675    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1676    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1677    {
1678       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1679       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1680       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1681       return RFAILED;
1682    }
1683
1684    for(idx=0; idx<elementCnt; idx++)
1685    {
1686       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1687       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1688       {
1689          for(ieId=0; ieId<idx; ieId++)
1690          {
1691             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1692          }
1693          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1694          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1695          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1696          return RFAILED;
1697       }
1698    }
1699
1700    /* GNB CU UE F1AP ID */
1701    idx = 0;
1702    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1703    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1704    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1705    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1706
1707    /* GNB DU UE F1AP ID */
1708    idx++;
1709    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1710    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1711    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1712    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1713
1714    /* SRBID */
1715    idx++;
1716    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1717    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1718    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1719    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1720
1721    /* RRCContainer */
1722    idx++;
1723    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1724    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1725    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1726    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1727
1728    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1729
1730    /* Encode the F1SetupRequest type as APER */
1731    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1732    encBufSize = 0;
1733    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1734          encBuf);
1735    /* Encode results */
1736    if(encRetVal.encoded == ENCODE_FAIL)
1737    {
1738       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1739             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1740       return RFAILED;
1741    }
1742    else
1743    {
1744       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1745       for(int i=0; i< encBufSize; i++)
1746       {
1747          DU_LOG("%x",encBuf[i]);
1748       }
1749    }
1750
1751    /* Sending  msg  */
1752    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1753    {
1754       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1755       return RFAILED;
1756    }
1757    freeDlRrcMessageTransfer(f1apMsg);
1758    return ROK;
1759 }/* End of BuildAndSendDLRRCMessageTransfer */
1760
1761 /*******************************************************************
1762  *
1763  * @brief Function to set the Dl RRC Msg Type
1764  *
1765  * @details
1766  *
1767  *    Function : setDlRRCMsgType
1768  *
1769  *    Functionality: Constructs the UE Setup Response and sends
1770  *                   it to the DU through SCTP.
1771  *
1772  * @params[in]
1773  *
1774  * @return ROK     - success
1775  *         RFAILED - failure
1776  *
1777  * ****************************************************************/
1778
1779 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1780 {
1781    uint8_t rrcMsgType = 0;
1782    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1783    {
1784       case RRC_SETUP:
1785          rrcMsgType = RRC_SETUP;
1786          break;
1787       case RRC_SETUP_COMPLETE:
1788          rrcMsgType = RRC_SETUP_COMPLETE;
1789          break;
1790       case NAS_SECURITY_MODE_COMPLETE:
1791          rrcMsgType = NAS_SECURITY_MODE_COMPLETE;
1792          break;
1793       case RRC_SECURITY_MODE_COMPLETE:
1794          rrcMsgType = RRC_SECURITY_MODE_COMPLETE;
1795          break;
1796       case REGISTRATION_COMPLETE:
1797          rrcMsgType = REGISTRATION_COMPLETE;
1798          break;
1799       case UE_CONTEXT_SETUP_RSP:
1800          rrcMsgType = UE_CONTEXT_SETUP_RSP;
1801          break;
1802       case RRC_RECONFIG_COMPLETE:
1803          rrcMsgType = RRC_RECONFIG_COMPLETE;
1804          break;
1805       default:
1806          break;
1807    }
1808    return rrcMsgType;
1809 }
1810
1811 #ifdef NR_DRX
1812 /*******************************************************************
1813  *
1814  * @brief fill long cycle offset value of drx
1815  *
1816  * @details
1817  *
1818  *    Function : fillLongCycleOffsetValue
1819  *
1820  *    Functionality: fill long cycle offset value of drx
1821  *
1822  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
1823  * struct DRX_ConfigRrc__drx_LongCycleStartOffset recvedLongCycleOffsetVal
1824  *
1825  * @return ROK     - success
1826  *         RFAILED - failure
1827  *
1828  * ****************************************************************/
1829 void fillLongCycleOffsetValue(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset *recvedLongCycleOffsetVal)
1830 {
1831
1832    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = recvedLongCycleOffsetVal->present;
1833    switch(recvedLongCycleOffsetVal->present)
1834    {
1835       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
1836          {
1837             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10;
1838             break;
1839          }
1840       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
1841          {
1842             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms20;
1843             break;
1844          }
1845       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
1846          {
1847             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms32;
1848             break;
1849          }
1850       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
1851          {
1852             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms40;
1853             break;
1854          }
1855       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
1856          {
1857             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms60;
1858             break;
1859          }
1860       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
1861          {
1862             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms64;
1863             break;
1864          }
1865       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
1866          {
1867             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms70;
1868             break;
1869          }
1870       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
1871          {
1872             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms80;
1873             break;
1874          }
1875       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
1876          {
1877             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms128;
1878             break;
1879          }
1880       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
1881          {
1882             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms160;
1883             break;
1884          }
1885       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
1886          {
1887             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms256;
1888             break;
1889          }
1890       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
1891          {
1892             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms320;
1893             break;
1894          }
1895       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
1896          {
1897             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms512;
1898             break;
1899          }
1900       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
1901          {
1902             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms640;
1903             break;
1904          }
1905       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
1906          {
1907             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1024;
1908             break;
1909          }
1910       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
1911          {
1912             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms1280;
1913             break;
1914          }
1915       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
1916          {
1917             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2048;
1918             break;
1919          }
1920       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
1921          {
1922             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms2560;
1923             break;
1924          }
1925       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
1926          {
1927             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms5120;
1928             break;
1929          }
1930       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
1931          {
1932             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = recvedLongCycleOffsetVal->choice.ms10240;
1933             break;
1934          }
1935       default :
1936          break;
1937    }
1938 }
1939
1940 /*******************************************************************
1941  *
1942  * @brief Extract configuration from DRX_ConfigRrc
1943  *    and store the drx configuration in UeCb
1944  *
1945  * @details
1946  *
1947  *    Function : storeDrxCfgInUeCb
1948  *
1949  *    Functionality: Store drx configuration in UeCb
1950  *
1951  * @params[in] (struct DRX_ConfigRrc *setup, DrxCfg *drxCfg)
1952  *
1953  * @return void
1954  * ****************************************************************/
1955 void storeDrxCfgInUeCb(struct DRX_ConfigRrc *drxSetup, DrxCfg *drxCfg)
1956 {
1957    switch(drxSetup->drx_onDurationTimer.present)
1958    {
1959       case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
1960          break;
1961       case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
1962          {
1963             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
1964             drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=drxSetup->drx_onDurationTimer.choice.milliSeconds;
1965             break;
1966          }
1967       case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
1968          {
1969             drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
1970             drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = drxSetup->drx_onDurationTimer.choice.subMilliSeconds;
1971             break;
1972          }
1973    }
1974    fillLongCycleOffsetValue(&drxCfg->drxLongCycleStartOffset, &drxSetup->drx_LongCycleStartOffset);
1975    drxCfg->drxInactivityTimer = drxSetup->drx_InactivityTimer;
1976    drxCfg->drxHarqRttTimerDl = drxSetup->drx_HARQ_RTT_TimerDL;
1977    drxCfg->drxHarqRttTimerUl = drxSetup->drx_HARQ_RTT_TimerUL;
1978    drxCfg->drxRetransmissionTimerDl = drxSetup->drx_RetransmissionTimerDL;
1979    drxCfg->drxRetransmissionTimerUl = drxSetup->drx_RetransmissionTimerUL;
1980    drxCfg->drxSlotOffset = drxSetup->drx_SlotOffset;
1981    if(drxSetup->shortDRX)
1982    {
1983       drxCfg->shortDrxPres=true;
1984       drxCfg->shortDrx.drxShortCycle = drxSetup->shortDRX->drx_ShortCycle;
1985       drxCfg->shortDrx.drxShortCycleTimer = drxSetup->shortDRX->drx_ShortCycleTimer;
1986    }
1987    else
1988       drxCfg->shortDrxPres=false;
1989 }
1990 #endif
1991
1992 /*******************************************************************
1993  *
1994  * @brief Extract configuration from CellGroupConfig
1995  *
1996  * @details
1997  *
1998  *    Function : extractCellGroupConfig
1999  *
2000  *    Functionality: Extract configuration from CellGroupConfig
2001  *        and store in local database
2002  *
2003  * @params[in] UE control block
2004  *             Cell Group Config
2005  *
2006  * @return ROK     - success
2007  *         RFAILED - failure
2008  *
2009  * ****************************************************************/
2010 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
2011 {
2012    uint8_t rbIdx, srbIdx, drbIdx;
2013    bool    srbFound, drbFound;
2014    SrbInfo *srbCfgDb = NULLP;
2015    DrbInfo *drbCfgDb = NULLP;
2016    RlcLcCfg *rlcLcCfgDb = NULLP;
2017    MacLcCfg *macLcCfgDb = NULLP;
2018    RLC_BearerConfig_t *rlcCfg = NULLP;
2019    RLC_Config_t *rlcLcCfg = NULLP;
2020    LogicalChannelConfig_t *macLcCfg = NULLP;
2021 #ifdef NR_DRX
2022    DrxCfg    drxCfg;
2023 #endif
2024
2025    if(ueCb == NULLP)
2026    {
2027       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
2028       return RFAILED;
2029    }
2030
2031    if(cellGrpCfg == NULLP)
2032    {
2033       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
2034       return RFAILED;
2035    }
2036
2037 #ifdef NR_DRX
2038    if(cellGrpCfg->mac_CellGroupConfig)
2039    {
2040       if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc)
2041       {
2042          switch(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->present)
2043          {
2044             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
2045                break;
2046
2047             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
2048             {
2049                if(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup)
2050                {
2051                   ueCb->drxCfgPresent = true;
2052                   storeDrxCfgInUeCb(cellGrpCfg->mac_CellGroupConfig->drx_ConfigRrc->choice.setup, &ueCb->drxCfg);
2053                }
2054                break;
2055             }
2056
2057             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
2058                break;
2059          }
2060       }
2061    }
2062 #endif
2063
2064    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
2065    {
2066       srbFound = false;
2067       drbFound = false;
2068
2069       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
2070
2071       /* Update SRB configuration in local DB */
2072       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
2073       {
2074          /* Search if SRB entry is already present in DB */
2075          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
2076          {
2077             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
2078             {
2079               srbCfgDb = &ueCb->srbList[srbIdx];
2080               srbFound = true;
2081               break;
2082             }
2083          }
2084
2085          /* If not, add SRB to UE CB's SRB list */
2086          if(!srbFound)
2087          {
2088             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
2089             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
2090             ueCb->numSrb++;
2091          }
2092
2093          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2094          srbCfgDb->cfgSentToUe = false;
2095          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
2096          macLcCfgDb = &srbCfgDb->macLcCfg;
2097       }
2098
2099       /* Update DRB configuration in local DB */
2100       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
2101       {
2102          /* Search if DRB entry is already present in DB */
2103          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
2104          {
2105             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
2106             {
2107               drbCfgDb = &ueCb->drbList[drbIdx];
2108               drbFound = true;
2109               break;
2110             }
2111          }
2112
2113          /* If not, add DRB to UE CB's SRB list */
2114          if(!drbFound)
2115          {
2116             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
2117             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
2118             ueCb->numDrb++;
2119          }
2120
2121          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
2122          drbCfgDb->cfgSentToUe = false;
2123          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
2124          macLcCfgDb = &drbCfgDb->macLcCfg;
2125       }
2126
2127
2128       /* Update RLC configuration for this RB */
2129       rlcLcCfg = rlcCfg->rlc_Config;
2130       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
2131       switch(rlcLcCfgDb->rlcMode)
2132       {
2133          case RLC_Config_PR_am:
2134             {
2135                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
2136                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
2137                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
2138                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
2139                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
2140
2141                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
2142                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
2143                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
2144                break;
2145             }
2146
2147          case RLC_Config_PR_um_Bi_Directional:
2148             {
2149                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
2150
2151                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
2152                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
2153                break;
2154             }
2155       }
2156
2157       /* Update MAC configuration for this LC */
2158       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
2159       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
2160       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
2161       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
2162       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
2163       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
2164    }
2165    return ROK;
2166 }
2167
2168 /*******************************************************************
2169  *
2170  * @brief Function to decode DU to CU RRC container
2171  *
2172  * @details
2173  *
2174  *    Function : extractDuToCuRrcCont
2175  *
2176  *    Functionality: Function to decode DU to CU RRC container
2177  *
2178  * @params[in] UE Cb
2179  *             RRC conatiner octect string to be decoded
2180  *
2181  * @return ROK     - success
2182  *         RFAILED - failure
2183  *
2184  * ****************************************************************/
2185 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
2186 {
2187    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
2188    asn_dec_rval_t rval; /* Decoder return value */
2189
2190    /* Copy the received container to UeCb */
2191    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
2192
2193    /* Decoding DU to CU RRC container octet string to cell group config */
2194    cellGrpCfgMsg = &cellGrpCfg;
2195    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
2196
2197    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
2198
2199    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2200    {
2201       DU_LOG("\nERROR  -->  F1AP : ASN decode failed in extractDuToCuRrcCont");
2202       return RFAILED;
2203    }
2204    printf("\n");
2205    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
2206
2207    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
2208    {
2209       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
2210       return RFAILED;
2211    }
2212
2213    return ROK;
2214 }
2215
2216 /*******************************************************************
2217  *
2218  * @brief Function to build Initial UL RRC Message
2219  *
2220  * @details
2221  *
2222  *    Function : procInitULRRCMsg
2223  *
2224  *    Functionality: Function to build Initial UL RRC Message
2225  *
2226  * @params[in]
2227  *
2228  * @return ROK     - success
2229  *         RFAILED - failure
2230  *
2231  * ****************************************************************/
2232
2233 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2234 {
2235    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
2236    uint8_t ret =ROK;
2237    uint16_t cellIdx=0, nrCellId = 0;
2238    uint32_t crnti;
2239    DuDb     *duDb;
2240    CuCellCb *cellCb;
2241    CuUeCb   *ueCb;
2242    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2243
2244    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2245
2246    SEARCH_DU_DB(duIdx, duId, duDb);
2247    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2248
2249    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2250    {
2251       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2252       {
2253          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2254             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2255             break;
2256
2257          case ProtocolIE_ID_id_NRCGI:
2258             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2259             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2260             if(cellCb == NULLP)
2261                return RFAILED;
2262             break;
2263
2264          case ProtocolIE_ID_id_C_RNTI:
2265             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2266             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2267             {
2268                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2269                memset(ueCb, 0, sizeof(CuUeCb));
2270                ueCb->cellCb = cellCb;
2271                ueCb->crnti = crnti;
2272                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2273                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2274                ueCb->state = UE_ATTACH_IN_PROGRESS;
2275                (duDb->numUe)++;
2276
2277                cellCb->ueCb[cellCb->numUe] = ueCb;
2278                cellCb->numUe++;
2279             }
2280             break;
2281
2282          case ProtocolIE_ID_id_RRCContainer:
2283             break;
2284
2285          case ProtocolIE_ID_id_DUtoCURRCContainer:
2286             {
2287                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2288                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2289                {
2290                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2291                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2292                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2293                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2294                   {
2295                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2296                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2297                         ueCb->f1apMsgDb.duToCuContainer.size);
2298                   }
2299                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2300                   {
2301                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2302                      ret = RFAILED;
2303                   }
2304                }
2305                else
2306                {
2307                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2308                   ret = RFAILED;
2309                }
2310                break;
2311             }
2312
2313          default:
2314             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2315             break;
2316       }
2317       if(ret == RFAILED)
2318          break;
2319    }
2320
2321    if(ret == ROK)
2322    {
2323       ueCb->f1apMsgDb.dlRrcMsgCount++;
2324       rrcMsgType = setDlRRCMsgType(ueCb);
2325       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2326    }
2327    return ret;
2328 }
2329
2330 /*******************************************************************
2331  *
2332  * @brief Builds Nrcgi
2333  *
2334  * @details
2335  *
2336  *    Function : BuildNrcgi
2337  *
2338  *    Functionality: Building the PLMN ID and NR Cell id
2339  *
2340  * @params[in] NRCGI_t *nrcgi
2341  * @return ROK     - success
2342  *         RFAILED - failure
2343  *
2344  * ****************************************************************/
2345 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2346 {
2347    uint8_t ret;
2348    uint8_t unused_bits = 4;
2349    uint8_t byteSize = 5;
2350
2351    /* Allocate Buffer Memory */
2352    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2353    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2354    if(nrcgi->pLMN_Identity.buf == NULLP)
2355    {
2356       return RFAILED;
2357    }
2358    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2359
2360    if(ret != ROK)
2361    {
2362       return RFAILED;
2363    }
2364    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2365    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2366    if(nrcgi->nRCellIdentity.buf == NULLP)
2367    {
2368       return RFAILED;
2369    }
2370    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2371
2372    return ROK;
2373 }
2374 /*******************************************************************
2375  *
2376  * @brief Builds Special cell list for UE Setup Request
2377  *
2378  * @details
2379  *
2380  *    Function : BuildSplCellList
2381  *
2382  *    Functionality: Constructs the Special Cell list for UESetReq
2383  *
2384  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2385  *
2386  * @return ROK     - success
2387  *         RFAILED - failure
2388  *
2389  * ****************************************************************/
2390 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2391 {
2392    uint8_t  cellCnt;
2393    uint8_t  idx;
2394    uint8_t  ret;
2395    cellCnt = 1;
2396    spCellLst->list.count = cellCnt;
2397    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2398    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2399    if(spCellLst->list.array == NULLP)
2400    {
2401       return RFAILED;
2402    }
2403    for(idx=0; idx<cellCnt; idx++)
2404    {
2405       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2406       if(spCellLst->list.array[idx] == NULLP)
2407       {
2408          return RFAILED;
2409       }
2410    }
2411    idx = 0;
2412    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2413    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2414    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2415
2416    /* Special Cell ID -NRCGI */
2417    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2418    if(ret != ROK)
2419    {
2420       return RFAILED;
2421    }
2422    /*Special Cell Index*/
2423    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2424    return ROK;
2425 }/* End of BuildSplCellList*/
2426
2427 /*******************************************************************
2428  *
2429  * @brief Builds SRBS to be setup
2430  *
2431  * @details
2432  *
2433  *    Function : BuildSRBSetup
2434  *
2435  *    Functionality: Constructs the SRB's for UESetReq
2436  *
2437  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2438  *
2439  * @return ROK     - success
2440  *         RFAILED - failure
2441  *
2442  * ****************************************************************/
2443 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2444 {
2445    uint8_t idx;
2446    uint8_t srbCnt;
2447
2448    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2449       srbCnt = ueCb->numSrb;
2450    else
2451       srbCnt = 1;
2452    srbSet->list.count = srbCnt;
2453    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2454    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2455    if(srbSet->list.array == NULLP)
2456    {
2457       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2458       return RFAILED;
2459    }
2460
2461    for(idx=0; idx<srbCnt; idx++)
2462    {
2463       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2464       if(srbSet->list.array[idx] == NULLP)
2465       {
2466          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2467          return RFAILED;
2468       }
2469    }
2470
2471    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2472    {
2473       idx = 0;
2474       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2475       srbSet->list.array[idx]->criticality = Criticality_ignore;
2476       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2477       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2478       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2479       ueCb->numSrb++;
2480    }
2481    else
2482    {
2483       for(idx=0; idx<srbCnt; idx++)
2484       {
2485          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2486          srbSet->list.array[idx]->criticality = Criticality_ignore;
2487          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2488          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2489       }
2490    }
2491    return ROK;
2492 }/* End of BuildSRBSetup*/
2493
2494 /*******************************************************************
2495  *
2496  * @brief Builds QOS Info for DRB Setum Item
2497  *
2498  * @details
2499  *
2500  *    Function : BuildQOSInfo
2501  *
2502  *    Functionality: Constructs the QOS Info for DRB Setup Item
2503  *
2504  * @params[in] QoSInformation_t *qosinfo
2505  *             int16_t pduSessionID
2506  *
2507  * @return ROK     - success
2508  *         RFAILED - failure
2509  *
2510  * ****************************************************************/
2511 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2512 {
2513    uint8_t elementCnt = 0, qosCntIdx = 0;
2514    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2515
2516    /* NonDynamic5QIDescriptor */
2517    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2518    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2519    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2520    {
2521       return RFAILED;
2522    }
2523
2524    if(hoInProgress)
2525       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2526    else
2527    {
2528       /*FiveQI*/
2529       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2530          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2531       else
2532          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2533
2534       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2535    }
2536
2537    if(!hoInProgress)
2538    {
2539       /*AveragingWindow*/
2540       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2541       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2542       {
2543          return RFAILED;
2544       }
2545       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2546       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2547
2548       /*MaxDataBurstVolume*/
2549       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2550       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2551       {
2552          return RFAILED;
2553       }
2554       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2555       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2556    }
2557
2558    /*nRGRAN Allocation Retention Priority*/
2559    if(hoInProgress)
2560    {
2561       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2562       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2563       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2564    }
2565    else
2566    {
2567       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2568       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2569       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2570
2571       qosInfo->priorityLevel = PriorityLevel_lowest;
2572       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2573       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2574    }
2575
2576    /* PDU session ID */
2577    if(!hoInProgress)
2578    {
2579       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2580       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2581       {
2582          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2583          return ROK;
2584       }
2585
2586       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2587       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2588
2589       if(qosIeExt)
2590       {
2591          elementCnt = NUM_QOS_EXT;
2592          qosIeExt->list.count = elementCnt;
2593          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2594
2595          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2596          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2597
2598          if(qosIeExt->list.array == NULLP)
2599          {
2600             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2601             return  RFAILED;
2602          }
2603
2604          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2605          {
2606             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2607             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2608             {
2609                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2610                return  RFAILED;
2611             }
2612             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2613             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2614             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2615             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2616             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2617                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2618             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2619             qosInfo->pduSessionId = pduSessionID;
2620          }
2621       }
2622       else
2623       {
2624          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2625          return RFAILED;
2626       }
2627    }
2628    return ROK;
2629 }/*End of BuildQOSInfo*/
2630
2631 /*******************************************************************
2632  *
2633  * @brief Builds SNSSAI
2634  *
2635  * @details
2636  *
2637  *    Function : BuildSNSSAI
2638  *
2639  *    Functionality: Constructs the SNSSAI For DRB list
2640  *
2641  * @params[in] SNSSAI_t *snssai
2642  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2643  *
2644  * @return ROK     - success
2645  *         RFAILED - failure
2646  *
2647  * ****************************************************************/
2648 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2649 {
2650    /*SNSSAI*/
2651    /*ssT*/
2652    snssai->sST.size = sizeof(uint8_t);
2653    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2654    if(snssai->sST.buf == NULLP)
2655    {
2656       return RFAILED;
2657    }
2658    if(!hoInProgress)
2659       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2660    else
2661       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2662
2663    /*sD*/
2664    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2665    if(snssai->sD == NULLP)
2666    {
2667       return RFAILED;
2668    }
2669    snssai->sD->size = 3 * sizeof(uint8_t);
2670    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2671    if(snssai->sD->buf == NULLP)
2672    {
2673       return RFAILED;
2674    }
2675    if(!hoInProgress)
2676       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2677    else
2678       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2679
2680    if(!hoInProgress)
2681       drbInfo->snssai = snssaiToCopy;
2682    return ROK;
2683 }/*End of BuildSNSSAI*/
2684
2685 /*******************************************************************
2686  *
2687  * @brief Builds the flow map.
2688  *
2689  * @details
2690  *
2691  *    Function : BuildFlowsMap
2692  *
2693  *    Functionality: Constructs the flowmap For DRB list
2694  *
2695  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2696  *
2697  * @return ROK     - success
2698  *         RFAILED - failure
2699  *
2700  * ****************************************************************/
2701 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2702 {
2703    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2704    FlowsMapped *qosFlow;
2705
2706    if(!hoInProgress)
2707       flowCnt = 1;
2708    else
2709       flowCnt = drbInfo->numFlowMap;
2710    flowMap->list.count = flowCnt;
2711    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2712    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2713    if(flowMap->list.array == NULLP)
2714    {
2715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2716       return RFAILED;
2717    }
2718    for(idx=0; idx<flowCnt; idx++)
2719    {
2720       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2721       if(flowMap->list.array[idx] == NULLP)
2722       {
2723          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2724          return RFAILED;
2725       }
2726
2727       if(!hoInProgress)
2728       {
2729          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2730          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2731          {
2732             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2733             {
2734                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2735                {
2736                   qosFlow = &drbInfo->flowMapList[flowIdx];
2737                   break;
2738                }
2739             }
2740          }
2741          else
2742          {
2743             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2744             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2745          }
2746       }
2747       else
2748       {
2749          qosFlow = &drbInfo->flowMapList[idx];
2750          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2751       }
2752
2753       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2754             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2755       if(ret != ROK)
2756       {
2757          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2758          return RFAILED;
2759       }
2760
2761       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2762          drbInfo->numFlowMap++;
2763    }
2764    return ROK;
2765 }/*End of BuildFlowsMap*/
2766
2767 /*******************************************************************
2768  *
2769  * @brief Builds the Uplink Tunnel Info
2770  *
2771  * @details
2772  *
2773  *    Function : BuildULTnlInfo
2774  *
2775  *    Functionality: Constructs the UL TnlInfo For DRB list
2776  *
2777  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2778  *
2779  * @return ROK     - success
2780  *         RFAILED - failure
2781  *
2782  * ****************************************************************/
2783 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2784 {
2785    uint8_t idx;
2786    uint8_t ulCnt;
2787
2788    ulCnt = 1;
2789    ulInfo->list.count = ulCnt;
2790    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2791    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2792    if(ulInfo->list.array == NULLP)
2793    {
2794       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2795       return RFAILED;
2796    }
2797    for(idx=0; idx<ulCnt; idx++)
2798    {
2799       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2800       if(ulInfo->list.array[idx] == NULLP)
2801       {
2802          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2803               return RFAILED;
2804       }
2805    }
2806    idx = 0;
2807    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2808    /*GTP TUNNEL*/
2809    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2810    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2811    {
2812       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2813       return RFAILED;
2814    }
2815    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2816    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2817       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2818    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2819    {
2820       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2821       return RFAILED;
2822    }
2823
2824    if(!hoInProgress)
2825    {
2826       /* NOTE: Below IP address must be changed if running on different IP configuration */
2827       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2828       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2829       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2830       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2831       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2832
2833       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2834       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2835       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2836       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2837    }
2838    else
2839    {
2840       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2841       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2842       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2843       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2844       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2845    }
2846
2847    /*GTP TEID*/
2848    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2849    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2850       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2851    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2852    {
2853       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2854       return RFAILED;
2855    }
2856
2857    if(!hoInProgress)
2858    {
2859       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2860       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2861       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2862       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2863
2864       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2865       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2866       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2867       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2868    }
2869    else
2870    {
2871       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2872       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2873       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2874       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2875    }
2876    return ROK;
2877 }/*End of BuildULTnlInfo*/
2878
2879 /*******************************************************************
2880  *
2881  * @brief Builds DRBS to be setup
2882  *
2883  * @details
2884  *
2885  *    Function : BuildDRBSetup
2886  *
2887  *    Functionality: Constructs the DRB's for UESetReq
2888  *
2889  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2890  *
2891  * @return ROK     - success
2892  *         RFAILED - failure
2893  *
2894  * ****************************************************************/
2895 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2896 {
2897    uint16_t snssaiIdx=0;
2898    uint8_t idx = 0, extIeIdx = 0;
2899    uint8_t elementCnt = 0, drbCnt = 0;
2900    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2901    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2902    DRBs_ToBeSetup_Item_t *drbSetItem;
2903    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2904    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2905
2906    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2907       drbCnt = ueCb->numDrb;
2908    else
2909       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2910    drbSet->list.count = drbCnt;
2911
2912    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2913    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2914    if(drbSet->list.array == NULLP)
2915    {
2916       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2917       return RFAILED;
2918    }
2919
2920    for(idx=0; idx<drbCnt; idx++)
2921    {
2922       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2923       if(drbSet->list.array[idx] == NULLP)
2924       {
2925          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2926          return RFAILED;
2927       }
2928
2929       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2930       drbSet->list.array[idx]->criticality = Criticality_ignore;
2931       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2932       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2933       /*dRBID*/
2934       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2935       {
2936          drbSetItem->dRBID = idx + 1;
2937          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2938       }
2939       else
2940          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2941
2942       /*qoSInformation*/
2943       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2944       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2945       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2946       {
2947          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2948          return RFAILED;
2949       }
2950       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2951       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2952       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2953       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2954          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2955                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2956       else
2957          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2958                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2959       if(BuildQOSInforet != ROK)
2960       {
2961          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2962          return RFAILED;
2963       }
2964
2965       /*SNSSAI*/
2966       snssaiIdx = (idx% cuCb.numSnssaiSupported);
2967       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2968          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2969                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[snssaiIdx], FALSE);
2970       else
2971          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2972                choice_extension->value.choice.DRB_Information.sNSSAI, NULLP, TRUE);
2973       if(BuildSNSSAIret != ROK)
2974       {
2975          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2976          return RFAILED;
2977       }
2978
2979       /*Flows mapped to DRB List*/
2980       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2981          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2982                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2983       else
2984          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2985                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2986       if(BuildFlowsMapret != ROK)
2987       {
2988          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2989          return RFAILED;
2990       }
2991
2992       /*ULUPTNLInformation To Be Setup List*/
2993       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2994          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2995                FALSE);
2996       else
2997          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2998                TRUE);
2999       if(BuildULTnlInforet != ROK)
3000       {
3001          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
3002          return RFAILED;
3003       }
3004
3005       /*RLCMode*/
3006       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3007       {
3008          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
3009          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
3010       }
3011       else
3012          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
3013
3014       /* DL PDCP SN Length */
3015       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
3016       {
3017          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
3018          if(!drbToBeSetupExt)
3019          {
3020             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
3021             return RFAILED;
3022          }
3023
3024          elementCnt = 1;
3025          drbToBeSetupExt->list.count = elementCnt;
3026          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
3027
3028          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
3029          if(!drbToBeSetupExt->list.array)
3030          {
3031              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
3032              return RFAILED;
3033          }
3034
3035          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
3036          {
3037             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
3038             if(!drbToBeSetupExt->list.array[extIeIdx])
3039             {
3040                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
3041                return RFAILED;
3042             }
3043          }
3044
3045          extIeIdx = 0;
3046          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
3047
3048          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
3049          drbToBeSetupExtIe->criticality = Criticality_ignore;
3050          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
3051          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
3052          drbSetItem->iE_Extensions = drbToBeSetupExt;
3053       }
3054
3055       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
3056          ueCb->numDrb++;
3057    }
3058    return ROK;
3059 }/* End of BuildDRBSetup*/
3060
3061 /*******************************************************************
3062  *
3063  * @brief Deallocating memory of function BuildAndSendUESetReq
3064  *
3065  * @details
3066  *
3067  *    Function : FreeNrcgi
3068  *
3069  *    Functionality: Deallocating memory for function BuildNrcgi
3070  *
3071  * @params[in] NRCGI_t *nrcgi
3072  *
3073  * @return void
3074  *
3075  *******************************************************************/
3076 void FreeNrcgi(NRCGI_t *nrcgi)
3077 {
3078    if(nrcgi->pLMN_Identity.buf != NULLP)
3079    {
3080       if(nrcgi->nRCellIdentity.buf != NULLP)
3081       {
3082          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
3083       }
3084       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
3085    }
3086 }
3087 /*******************************************************************
3088  *
3089  * @brief  Deallocating memory of function BuildAndSendUESetReq
3090  *
3091  * @details
3092  *
3093  *    Function : FreeSplCellList
3094  *
3095  *    Functionality: Deallocating memory for function BuildSplCellList
3096  *
3097  * @params[in] SCell_ToBeSetup_List_t *spCellLst
3098  *
3099  * @return void
3100  *
3101  *
3102  * *****************************************************************/
3103 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
3104 {
3105    uint8_t  cellidx;
3106    if(spCellLst->list.array != NULLP)
3107    {
3108       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
3109       {
3110          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
3111          {
3112             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
3113          }
3114          if(spCellLst->list.array[cellidx]!=NULLP)
3115          {
3116             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
3117          }
3118       }
3119       CU_FREE(spCellLst->list.array,spCellLst->list.size);
3120    }
3121 }
3122 /*******************************************************************
3123  *
3124  * @brief Deallocating memory of function BuildAndSendUESetReq
3125  *
3126  * @details
3127  *
3128  *    Function : FreeSRBSetup
3129  *
3130  *    Functionality: Deallocating memory for function BuildSRBSetup
3131  *
3132  * @params[in] SRBs_ToBeSetup_List_t *srbSet
3133  *
3134  * @return void
3135  *
3136  *
3137  * ******************************************************************/
3138 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
3139 {
3140    uint8_t srbidx;
3141    if(srbSet->list.array != NULLP)
3142    {
3143       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
3144       {
3145          if(srbSet->list.array[srbidx]!=NULLP)
3146          {
3147             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
3148          }
3149       }
3150       CU_FREE(srbSet->list.array,srbSet->list.size);
3151    }
3152 }
3153 /*******************************************************************
3154  *
3155  * @brief Deallocating memory of function BuildAndSendUESetReq
3156  *
3157  * @details
3158  *
3159  *    Function : FreeQOSInfo
3160  *
3161  *    Functionality:  Deallocating memory for function BuildQOSInfo
3162  *
3163  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
3164  *
3165  * @return void
3166  *
3167  * ****************************************************************/
3168 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
3169 {
3170    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3171    uint8_t qosCntIdx = 0;
3172
3173    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
3174    {
3175       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3176       {
3177          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3178          {
3179             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3180                   sizeof(MaxDataBurstVolume_t));
3181          }
3182          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
3183                sizeof(AveragingWindow_t));
3184       }
3185       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
3186             sizeof(NonDynamic5QIDescriptor_t));
3187    }
3188    if(drbQos->iE_Extensions)
3189    {
3190       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
3191       if(qosIeExt->list.array != NULLP)
3192       {
3193          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
3194          {
3195             if(qosIeExt->list.array[qosCntIdx])
3196             {
3197                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3198             }
3199          }
3200          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3201       }
3202
3203       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3204    }
3205 }
3206 /*******************************************************************
3207  *
3208  * @brief Deallocating memory of function BuildAndSendUESetReq
3209  *
3210  * @details
3211  *
3212  *    Function : FreeULTnlInfo
3213  *
3214  *    Functionality:  Deallocating memory for function BuildULTnlInfo
3215  *
3216  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
3217  *
3218  * @return void
3219  *
3220
3221  * ****************************************************************/
3222 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
3223 {
3224    uint8_t ulidx=0;
3225    if(ulInfo->list.array != NULLP)
3226    {
3227       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
3228       {
3229          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3230          {
3231             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3232             {
3233                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3234                      transportLayerAddress.buf != NULLP)
3235                {
3236                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3237                         !=NULLP)
3238                   {
3239                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3240                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3241                            gTPTunnel->gTP_TEID.size);
3242                   }
3243                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3244                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3245                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3246                }
3247                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3248                      sizeof(GTPTunnel_t));
3249             }
3250          }
3251          if(ulInfo->list.array[ulidx]!=NULLP)
3252          {
3253             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3254          }
3255       }
3256       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3257    }
3258 }
3259 /*******************************************************************
3260  *
3261  * @brief Deallocating memory for BuildAndSendUESetReq
3262  *
3263  * @details
3264  *
3265  *    Function : FreeDRBSetup
3266  *
3267  *    Functionality:  Deallocating memory for BuildDRBSetup
3268  *
3269  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3270  *
3271  * @return void
3272  *
3273  * ****************************************************************/
3274 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3275 {
3276    DRBs_ToBeSetup_Item_t *drbSetItem;
3277    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3278
3279    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3280
3281    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3282    if(drbSet->list.array != NULLP)
3283    {
3284       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3285       {
3286               if(drbSet->list.array[drbidx] != NULLP)
3287               {
3288                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3289                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3290                  {
3291                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3292                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3293                {
3294                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3295                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3296                             {
3297                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3298                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3299                                {
3300                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3301                                        {
3302                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3303                                           {
3304                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3305                                              {
3306                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3307                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3308                                                      {
3309                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3310                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3311                                                          {
3312                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3313                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3314                                                              {
3315                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3316                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3317                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3318                                                                      {
3319                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3320                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3321                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3322                                                                          {
3323                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3324                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3325                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3326                                                                                   {
3327                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3328                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3329
3330                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3331                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3332                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3333                                                                                                    sizeof(MaxDataBurstVolume_t));
3334                                                                                   }
3335                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3336                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3337                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3338                                                                          }
3339                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3340                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3341                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3342                                                                      }
3343                                                             }
3344                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3345                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3346                                                             {
3347                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3348                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3349                                                             }
3350                                                         }
3351                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3352                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3353                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3354                                                      }
3355                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3356                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3357                                             }
3358                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3359                                                               sizeof(OCTET_STRING_t));
3360                                        }
3361                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3362                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3363                                     }
3364                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3365                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3366                             }
3367                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3368                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3369                          }
3370                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3371                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3372              }
3373              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3374                         iE_Extensions != NULLP)
3375              {
3376                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3377                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3378                  if(qosIeExt->list.array != NULLP)
3379                  {
3380                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3381                    {
3382                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3383                       {
3384                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3385                       }
3386                     }
3387                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3388                   }
3389                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3390                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3391               }
3392
3393                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3394                 }
3395                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3396               }
3397       }
3398       CU_FREE(drbSet->list.array,drbSet->list.size);
3399    }
3400 }
3401
3402
3403 /*******************************************************************
3404  *
3405  * @brief Free the UE Setup Request
3406  *
3407  * @details
3408  *
3409  *    Function : FreeUeContextSetupReq
3410  *
3411  *    Functionality: Deallocate the memory of BuildUESetReq
3412  *
3413  * @params[in]  F1AP_PDU_t  *f1apMsg
3414  *
3415  * @return void
3416  *
3417  *
3418  * ****************************************************************/
3419 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3420 {
3421    uint8_t idx, ieId;
3422    UEContextSetupRequest_t  *ueSetReq = NULLP;
3423
3424    if(f1apMsg != NULLP)
3425    {
3426       if(f1apMsg->choice.initiatingMessage != NULLP)
3427       {
3428          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3429          if(ueSetReq->protocolIEs.list.array != NULLP)
3430          {
3431             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3432             {
3433                if(ueSetReq->protocolIEs.list.array[idx])
3434                {
3435                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3436                   {
3437                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3438                         break;
3439                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3440                         break;
3441                      case ProtocolIE_ID_id_SpCell_ID:
3442                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3443                         break;
3444                      case ProtocolIE_ID_id_ServCellIndex:
3445                         break;
3446                      case ProtocolIE_ID_id_SpCellULConfigured:
3447                         break;
3448                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3449                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3450                         break;
3451                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3452                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3453                         break;
3454                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3455                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3456                         break;
3457                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3458                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3459                         break;
3460                      case ProtocolIE_ID_id_RRCContainer:
3461                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3462                         {
3463                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3464                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3465                         }
3466                         break;
3467                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3468                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3469                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3470                         break;
3471                      default:
3472                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3473                         break;
3474                   }
3475                }
3476                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3477             }
3478             for(ieId=0; ieId<idx; ieId++)
3479             {
3480                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3481                {
3482                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3483                }
3484             }
3485             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3486          }
3487          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3488       }
3489       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3490    }
3491 }
3492
3493 /**Filling cell group info **/
3494 /*******************************************************************
3495  *
3496  * @brief Build Control resource set to add/modify list
3497  *
3498  * @details
3499  *
3500  *    Function : BuildControlRSetToAddModList
3501  *
3502  *    Functionality: Build Control resource set to add/modify list
3503  *
3504  * @params[in]
3505  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3506  *
3507  * @return ROK     - success
3508  *         RFAILED - failure
3509  *
3510  * ****************************************************************/
3511    uint8_t BuildControlRSetToAddModList
3512 (
3513  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3514  )
3515 {
3516    uint8_t idx;
3517    uint8_t elementCnt;
3518    uint8_t numBytes, bitsUnused;
3519    struct ControlResourceSet *controlRSet;
3520    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3521    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3522
3523    elementCnt = 1;
3524    controlRSetList->list.count = elementCnt;
3525    controlRSetList->list.size = \
3526                                 elementCnt * sizeof(struct ControlResourceSet *);
3527
3528    controlRSetList->list.array = NULLP;
3529    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3530    if(!controlRSetList->list.array)
3531    {
3532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3533       return RFAILED;
3534    }
3535
3536    for(idx = 0; idx < elementCnt; idx++)
3537    {
3538       controlRSetList->list.array[idx] = NULLP;
3539       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3540       if(!controlRSetList->list.array[idx])
3541       {
3542          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3543          return RFAILED;
3544       }
3545    }
3546
3547    idx=0;
3548    controlRSet = controlRSetList->list.array[idx];
3549    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3550
3551    /* Values harcoded according to our design:
3552     * size 6 bytes
3553     * 3 LSBs unsued
3554     * Bit string stored ff0000000000
3555     */
3556    numBytes = 6;
3557    bitsUnused = 3;
3558    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3559    controlRSet->frequencyDomainResources.buf = NULLP;
3560    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3561          controlRSet->frequencyDomainResources.size);
3562    if(!controlRSet->frequencyDomainResources.buf)
3563    {
3564       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3565       return RFAILED;
3566    }
3567
3568    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3569    coreset0EndPrb = CORESET0_END_PRB;
3570    coreset1StartPrb = coreset0EndPrb + 6;
3571    coreset1NumPrb = CORESET1_NUM_PRB;
3572    /* calculate the PRBs */
3573    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3574    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3575    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3576
3577    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3578    controlRSet->cce_REG_MappingType.present = \
3579                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3580
3581    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3582    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3583    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3584    controlRSet->tci_PresentInDCI = NULLP;
3585 #if 0
3586    uint8_t tciStateIdx;
3587
3588    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3589          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3590    if(!controlRset->tci_StatesPDCCH_ToAddList)
3591    {
3592       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3593       return RFAILED;
3594    }
3595
3596    elementCnt = 1;
3597    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3598    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3599    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3600          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3601       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3602       {
3603          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3604          return RFAILED;
3605       }
3606
3607    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3608    {
3609       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3610       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3611       {
3612          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3613          return RFAILED;
3614       }
3615    }
3616
3617    tciStateIdx = 0;
3618    /* TODO */
3619    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3620
3621    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3622    if(!controlRset->tci_PresentInDCI)
3623    {
3624       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3625       return RFAILED;
3626    }
3627    /* TODO */
3628    *(controlRset->tci_PresentInDCI);
3629 #endif
3630
3631    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3632    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3633    if(!controlRSet->pdcch_DMRS_ScramblingID)
3634    {
3635       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3636       return RFAILED;
3637    }
3638    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3639
3640    return ROK;
3641 } /* End BuildControlRSetToAddModList */
3642
3643 /*******************************************************************
3644  *
3645  * @brief Build search space to add/modify list
3646  *
3647  * @details
3648  *
3649  *    Function : BuildSearchSpcToAddModList
3650  *
3651  *    Functionality: Build search space to add/modify list
3652  *
3653  * @params[in]
3654  * @return ROK     - success
3655  *         RFAILED - failure
3656  *
3657  * ****************************************************************/
3658    uint8_t BuildSearchSpcToAddModList
3659 (
3660  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3661  )
3662 {
3663    uint8_t idx;
3664    uint8_t numBytes;
3665    uint8_t byteIdx;
3666    uint8_t bitsUnused;
3667    uint8_t elementCnt;
3668    struct SearchSpace *searchSpc;
3669
3670    elementCnt = 1;
3671    searchSpcList->list.count = elementCnt;
3672    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3673
3674    searchSpcList->list.array = NULLP;
3675    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3676    if(!searchSpcList->list.array)
3677    {
3678       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3679       return RFAILED;
3680    }
3681
3682    for(idx = 0; idx < elementCnt; idx++)
3683    {
3684       searchSpcList->list.array[idx] = NULLP;
3685       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3686       if(!searchSpcList->list.array[idx])
3687       {
3688          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3689          return RFAILED;
3690       }
3691    }
3692
3693    idx = 0;
3694    searchSpc = searchSpcList->list.array[idx];
3695
3696    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3697
3698    searchSpc->controlResourceSetId = NULLP;
3699    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3700    if(!searchSpc->controlResourceSetId)
3701    {
3702       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3703       return RFAILED;
3704    }
3705    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3706
3707    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3708    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3709          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3710    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3711    {
3712       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3713       return RFAILED;
3714    }
3715    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3716                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3717
3718    searchSpc->duration = NULLP;
3719    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3720    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3721    if(!searchSpc->monitoringSymbolsWithinSlot)
3722    {
3723       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3724       return RFAILED;
3725    }
3726
3727    /* Values taken from reference logs :
3728     * size 2 bytes
3729     * 2 LSBs unsued
3730     * Bit string stores 8000
3731     */
3732    numBytes = 2;
3733    bitsUnused = 2;
3734
3735    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3736    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3737    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3738          searchSpc->monitoringSymbolsWithinSlot->size);
3739    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3740    {
3741       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3742       return RFAILED;
3743    }
3744
3745    byteIdx = 0;
3746    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3747                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3748    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3749    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3750
3751    searchSpc->nrofCandidates = NULLP;
3752    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3753    if(!searchSpc->nrofCandidates)
3754    {
3755       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3756       return RFAILED;
3757    }
3758
3759    searchSpc->nrofCandidates->aggregationLevel1 = \
3760                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3761    searchSpc->nrofCandidates->aggregationLevel2 = \
3762                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3763    searchSpc->nrofCandidates->aggregationLevel4 = \
3764                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3765    searchSpc->nrofCandidates->aggregationLevel8 = \
3766                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3767    searchSpc->nrofCandidates->aggregationLevel16 = \
3768                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3769
3770    searchSpc->searchSpaceType = NULLP;
3771    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3772    if(!searchSpc->searchSpaceType)
3773    {
3774       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3775       return RFAILED;
3776    }
3777
3778    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3779
3780    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3781    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3782          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3783    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3784    {
3785       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3786       return RFAILED;
3787    }
3788    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3789                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3790
3791    return ROK;
3792 }/* End BuildSearchSpcToAddModList */
3793
3794 /*******************************************************************
3795  *
3796  * @brief Builds BWP DL dedicated PDCCH config
3797  *
3798  * @details
3799  *
3800  *    Function : BuildBWPDlDedPdcchCfg
3801  *
3802  *    Functionality: Builds BWP DL dedicated PDCCH config
3803  *
3804  * @params[in] struct PDCCH_Config *pdcchCfg
3805  *
3806  * @return ROK     - success
3807  *         RFAILED - failure
3808  *
3809  * ****************************************************************/
3810 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3811 {
3812    pdcchCfg->controlResourceSetToAddModList = NULLP;
3813    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3814          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3815    if(!pdcchCfg->controlResourceSetToAddModList)
3816    {
3817       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3818       return RFAILED;
3819    }
3820
3821    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3822    {
3823       return RFAILED;
3824    }
3825
3826    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3827
3828    pdcchCfg->searchSpacesToAddModList = NULLP;
3829    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3830          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3831    if(!pdcchCfg->searchSpacesToAddModList)
3832    {
3833       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3834       return RFAILED;
3835    }
3836
3837    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3838    {
3839       return RFAILED;
3840    }
3841
3842    pdcchCfg->searchSpacesToReleaseList = NULLP;
3843    pdcchCfg->downlinkPreemption = NULLP;
3844    pdcchCfg->tpc_PUSCH = NULLP;
3845    pdcchCfg->tpc_PUCCH = NULLP;
3846    pdcchCfg->tpc_SRS = NULLP;
3847
3848    return ROK;
3849 }
3850
3851 /*******************************************************************
3852  *
3853  * @brief Builds DMRS DL PDSCH Mapping type A
3854  *
3855  * @details
3856  *
3857  *    Function : BuildDMRSDLPdschMapTypeA
3858  *
3859  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3860  *
3861  * @params[in]
3862  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3863  * @return ROK     - success
3864  *         RFAILED - failure
3865  *
3866  * ****************************************************************/
3867    uint8_t BuildDMRSDLPdschMapTypeA
3868 (
3869  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3870  )
3871 {
3872    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3873    dmrsDlCfg->choice.setup = NULLP;
3874    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3875    if(!dmrsDlCfg->choice.setup)
3876    {
3877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3878       return RFAILED;
3879    }
3880
3881    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3882    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3883    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3884    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3885    {
3886       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3887       return RFAILED;
3888    }
3889    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3890
3891    dmrsDlCfg->choice.setup->maxLength = NULLP;
3892    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3893    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3894    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3895
3896    return ROK;
3897 }
3898
3899 /*******************************************************************
3900  *
3901  * @brief Builds TCI states to add/modify list
3902  *
3903  * @details
3904  *
3905  *    Function : BuildTCIStatesToAddModList
3906  *
3907  *    Functionality:Builds TCI states to add/modify list
3908  *
3909  * @params[in]
3910  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3911  *
3912  * @return ROK     - success
3913  *         RFAILED - failure
3914  *
3915  * ****************************************************************/
3916 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3917 {
3918    return ROK;
3919 }
3920
3921 /*******************************************************************
3922  *
3923  * @brief Builds PDSCH time domain allocation list
3924  *
3925  * @details
3926  *
3927  *    Function : BuildPdschTimeDomAllocList
3928  *
3929  *    Functionality: Builds PDSCH time domain allocation list
3930  *
3931  * @params[in]
3932  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3933  *
3934  * @return ROK     - success
3935  *         RFAILED - failure
3936  *
3937  * ****************************************************************/
3938    uint8_t BuildPdschTimeDomAllocList
3939 (
3940  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3941  )
3942 {
3943    uint8_t idx;
3944    uint8_t elementCnt;
3945    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3946
3947    timeDomAllocList->present = \
3948                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3949
3950    timeDomAllocList->choice.setup = NULLP;
3951    CU_ALLOC(timeDomAllocList->choice.setup, \
3952          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3953    if(!timeDomAllocList->choice.setup)
3954    {
3955       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3956       return RFAILED;
3957    }
3958
3959    elementCnt = 2;
3960    timeDomAllocList->choice.setup->list.count = elementCnt;
3961    timeDomAllocList->choice.setup->list.size = \
3962                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3963
3964    timeDomAllocList->choice.setup->list.array = NULLP;
3965    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3966          timeDomAllocList->choice.setup->list.size);
3967    if(!timeDomAllocList->choice.setup->list.array)
3968    {
3969       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3970       return RFAILED;
3971    }
3972
3973    for(idx = 0; idx < elementCnt; idx++)
3974    {
3975       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3976       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3977             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3978       if(!timeDomAllocList->choice.setup->list.array[idx])
3979       {
3980          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3981          return RFAILED;
3982       }
3983    }
3984
3985    idx = 0;
3986    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3987    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3988    if(!timeDomAlloc->k0)
3989    {
3990        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3991        return RFAILED;
3992    }
3993    *(timeDomAlloc->k0) = 0;
3994    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3995    timeDomAlloc->startSymbolAndLength = 66;
3996
3997    idx++;
3998    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3999    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
4000    if(!timeDomAlloc->k0)
4001    {
4002       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4003       return RFAILED;
4004    }
4005    *(timeDomAlloc->k0) = 1;
4006    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4007    timeDomAlloc->startSymbolAndLength = 66;
4008
4009    return ROK;
4010 }
4011
4012 /*******************************************************************
4013  *
4014  * @brief Builds PDSCH PRB Bundling type
4015  *
4016  * @details
4017  *
4018  *    Function : BuildPdschPrbBundlingType
4019  *
4020  *    Functionality: Builds PDSCH PRB Bundling type
4021  *
4022  * @params[in]
4023  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4024  *
4025  * @return ROK     - success
4026  *         RFAILED - failure
4027  *
4028  * ****************************************************************/
4029    uint8_t BuildPdschPrbBundlingType
4030 (
4031  struct PDSCH_Config__prb_BundlingType *prbBndlType
4032  )
4033 {
4034    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4035
4036    prbBndlType->choice.staticBundling = NULLP;
4037    CU_ALLOC(prbBndlType->choice.staticBundling, \
4038          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4039    if(!prbBndlType->choice.staticBundling)
4040    {
4041       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4042       return RFAILED;
4043    }
4044    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4045
4046    return ROK;
4047 }
4048
4049 /*******************************************************************
4050  *
4051  * @brief Builds BWP DL dedicated PDSCH config
4052  *
4053  * @details
4054  *
4055  *    Function : BuildBWPDlDedPdschCfg
4056  *
4057  *    Functionality: Builds BWP DL dedicated PDSCH config
4058  *
4059  * @params[in] struct PDSCH_Config *pdschCfg
4060  *
4061  * @return ROK     - success
4062  *         RFAILED - failure
4063  *
4064  * ****************************************************************/
4065 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4066 {
4067    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4068
4069    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4070    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4071          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4072    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4073    {
4074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4075       return RFAILED;
4076    }
4077
4078    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4079    {
4080       return RFAILED;
4081    }
4082
4083    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4084    pdschCfg->tci_StatesToAddModList = NULLP;
4085    pdschCfg->tci_StatesToReleaseList = NULLP;
4086    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4087 #if 0
4088    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4089    if(!pdschCfg->tci_StatesToAddModList)
4090    {
4091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4092       return RFAILED;
4093    }
4094    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4095    {
4096       return RFAILED;
4097    }
4098 #endif
4099
4100    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4101
4102    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4103    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4104          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4105    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4106    {
4107       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4108       return RFAILED;
4109    }
4110    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4111    {
4112       return RFAILED;
4113    }
4114    pdschCfg->pdsch_AggregationFactor = NULLP;
4115    pdschCfg->rateMatchPatternToAddModList = NULLP;
4116    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4117    pdschCfg->rateMatchPatternGroup1 = NULLP;
4118    pdschCfg->rateMatchPatternGroup2 = NULLP;
4119    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4120    pdschCfg->mcs_Table = NULLP;
4121
4122    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4123    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4124    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4125    {
4126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4127       return RFAILED;
4128    }
4129    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4130
4131    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4132    {
4133       return RFAILED;
4134    }
4135
4136    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4137    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4138    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4139    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4140    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4141    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4142    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4143
4144    return ROK;
4145 }
4146
4147 /*******************************************************************
4148  *
4149  * @brief Builds intitial DL BWP
4150  * @details
4151  *
4152  *    Function : BuildInitialDlBWP
4153  *
4154  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4155  *
4156  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4157  *
4158  * @return ROK     - success
4159  *         RFAILED - failure
4160  *
4161  * ****************************************************************/
4162 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4163 {
4164    dlBwp->pdcch_Config = NULLP;
4165    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4166    if(!dlBwp->pdcch_Config)
4167    {
4168       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4169       return RFAILED;
4170    }
4171    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4172
4173    dlBwp->pdcch_Config->choice.setup = NULLP;
4174    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4175    if(!dlBwp->pdcch_Config->choice.setup)
4176    {
4177       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4178       return RFAILED;
4179    }
4180    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4181    {
4182       return RFAILED;
4183    }
4184
4185    dlBwp->pdsch_Config = NULLP;
4186    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4187    if(!dlBwp->pdsch_Config)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4190       return RFAILED;
4191    }
4192    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4193
4194    dlBwp->pdsch_Config->choice.setup = NULLP;
4195    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4196    if(!dlBwp->pdsch_Config->choice.setup)
4197    {
4198       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4199       return RFAILED;
4200    }
4201
4202    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4203    {
4204       return RFAILED;
4205    }
4206
4207    dlBwp->sps_Config = NULLP;
4208    dlBwp->radioLinkMonitoringConfig = NULLP;
4209    return ROK;
4210 }
4211
4212 /*******************************************************************
4213  *
4214  * @brief Builds DMRS UL Pusch Mapping type A
4215  *
4216  * @details
4217  *
4218  *    Function : BuildDMRSULPuschMapTypeA
4219  *
4220  *    Functionality: Builds DMRS UL Pusch Mapping type A
4221  *
4222  * @params[in]
4223  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4224  * @return ROK     - success
4225  *         RFAILED - failure
4226  *
4227  * ****************************************************************/
4228    uint8_t BuildDMRSULPuschMapTypeA
4229 (
4230  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4231  )
4232 {
4233    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4234    dmrsUlCfg->choice.setup= NULLP;
4235    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4236    if(!dmrsUlCfg->choice.setup)
4237    {
4238       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4239       return RFAILED;
4240    }
4241
4242    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4243    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4244    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4245    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4246    {
4247       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4248       return RFAILED;
4249    }
4250    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4251
4252    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4253    dmrsUlCfg->choice.setup->maxLength = NULLP;
4254    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4255    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4256          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4257    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4258    {
4259       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4260       return RFAILED;
4261    }
4262
4263    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4264    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4265          sizeof(long));
4266    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4267    {
4268       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4269       return RFAILED;
4270    }
4271    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4272
4273    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4274    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4275    return ROK;
4276 }
4277
4278 /*******************************************************************
4279  *
4280  * @brief Build PUSCH time domain allocation list
4281  *
4282  * @details
4283  *
4284  *    Function : BuildPuschTimeDomAllocList
4285  *
4286  *    Functionality: Build PUSCH time domain allocation list
4287  *
4288  * @params[in]
4289  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4290  *
4291  * @return ROK     - success
4292  *         RFAILED - failure
4293  *
4294  * ****************************************************************/
4295    uint8_t BuildPuschTimeDomAllocList
4296 (
4297  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4298  )
4299 {
4300    uint8_t idx;
4301    uint8_t elementCnt;
4302    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4303
4304    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4305    timeDomAllocList->choice.setup = NULLP;
4306    CU_ALLOC(timeDomAllocList->choice.setup, \
4307          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4308    if(!timeDomAllocList->choice.setup)
4309    {
4310       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4311       return RFAILED;
4312    }
4313
4314    elementCnt = 2;
4315    timeDomAllocList->choice.setup->list.count = elementCnt;
4316    timeDomAllocList->choice.setup->list.size = \
4317                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4318    timeDomAllocList->choice.setup->list.array = NULLP;
4319    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4320          timeDomAllocList->choice.setup->list.size);
4321    if(!timeDomAllocList->choice.setup->list.array)
4322    {
4323       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4324       return RFAILED;
4325    }
4326
4327    for(idx = 0; idx < elementCnt; idx++)
4328    {
4329       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4330       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4331             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4332       if(!timeDomAllocList->choice.setup->list.array[idx])
4333       {
4334          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4335          return RFAILED;
4336       }
4337    }
4338
4339    idx = 0;
4340    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4341    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4342    if(!timeDomAlloc->k2)
4343    {
4344       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4345       return RFAILED;
4346    }
4347    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4348    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4349    timeDomAlloc->startSymbolAndLength = 66;
4350
4351    idx++;
4352    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4353    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4354    if(!timeDomAlloc->k2)
4355    {
4356        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4357        return RFAILED;
4358    }
4359    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4360    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4361    timeDomAlloc->startSymbolAndLength = 66;
4362
4363    return ROK;
4364 }
4365
4366 /*******************************************************************
4367  *
4368  * @brief Builds BWP UL dedicated PUSCH Config
4369  *
4370  * @details
4371  *
4372  *    Function : BuildBWPUlDedPuschCfg
4373  *
4374  *    Functionality:
4375  *      Builds BWP UL dedicated PUSCH Config
4376  *
4377  * @params[in] : PUSCH_Config_t *puschCfg
4378  *
4379  * @return ROK     - success
4380  *         RFAILED - failure
4381  *
4382  * ****************************************************************/
4383 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4384 {
4385    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4386    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4387    if(!puschCfg->dataScramblingIdentityPUSCH)
4388    {
4389       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4390       return RFAILED;
4391    }
4392    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4393
4394    puschCfg->txConfig = NULLP;
4395    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4396    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4397          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4398    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4399    {
4400       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4401       return RFAILED;
4402    }
4403
4404    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4405    {
4406       return RFAILED;
4407    }
4408
4409    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4410    puschCfg->pusch_PowerControl = NULLP;
4411    puschCfg->frequencyHopping = NULLP;
4412    puschCfg->frequencyHoppingOffsetLists = NULLP;
4413    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4414
4415    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4416    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4417          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4418    if(!puschCfg->pusch_TimeDomainAllocationList)
4419    {
4420       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4421       return RFAILED;
4422    }
4423
4424    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4425    {
4426       return RFAILED;
4427    }
4428
4429    puschCfg->pusch_AggregationFactor = NULLP;
4430    puschCfg->mcs_Table = NULLP;
4431    puschCfg->mcs_TableTransformPrecoder = NULLP;
4432    puschCfg->transformPrecoder = NULLP;
4433    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4434    if(!puschCfg->transformPrecoder)
4435    {
4436       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4437       return RFAILED;
4438    }
4439    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4440
4441    puschCfg->codebookSubset = NULLP;
4442    puschCfg->maxRank = NULLP;
4443    puschCfg->rbg_Size = NULLP;
4444    puschCfg->uci_OnPUSCH = NULLP;
4445    puschCfg->tp_pi2BPSK = NULLP;
4446
4447    return ROK;
4448 }
4449
4450 /*******************************************************************
4451  *
4452  * @brief Builds BWP UL dedicated PUCCH Config
4453  *
4454  * @details
4455  *
4456  *    Function : BuildBWPUlDedPucchCfg
4457  *
4458  *    Functionality:
4459  *      Builds BWP UL dedicated PUCCH Config
4460  *
4461  * @params[in] : PUCCH_Config_t *pucchCfg
4462  *
4463  * @return ROK     - success
4464  *         RFAILED - failure
4465  *
4466  * ****************************************************************/
4467 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4468 {
4469    uint8_t arrIdx, elementCnt;
4470    uint8_t rsrcIdx, rsrcSetIdx;
4471    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4472    PUCCH_Resource_t *rsrc = NULLP;
4473
4474    //RESOURCE SET
4475    elementCnt = 1;
4476    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4477    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4478    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4479    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4480    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4481    {
4482       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4483    }
4484    rsrcSetIdx = 0;
4485    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4486    rsrcSet->pucch_ResourceSetId = 1;
4487    elementCnt = 1;
4488    rsrcSet->resourceList.list.count = elementCnt;
4489    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4490    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4491    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4492    {
4493       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4494    }
4495    rsrcIdx = 0;
4496    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4497
4498    //RESOURCE
4499    elementCnt = 1;
4500    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4501    pucchCfg->resourceToAddModList->list.count = elementCnt;
4502    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4503    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4504    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4505    {
4506       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4507    }
4508    rsrcIdx = 0;
4509    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4510    rsrc->pucch_ResourceId = 1;
4511    rsrc->startingPRB = 0;
4512    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4513    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4514    rsrc->format.choice.format1->initialCyclicShift = 0;
4515    rsrc->format.choice.format1->nrofSymbols = 4;
4516    rsrc->format.choice.format1->startingSymbolIndex = 0;
4517    rsrc->format.choice.format1->timeDomainOCC = 0;
4518
4519    //PUCCH Format 1
4520    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4521    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4522    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4523    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4524    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4525
4526    //DL DATA TO UL ACK
4527    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4528    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4529    {
4530       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4531       return RFAILED;
4532    }
4533
4534    elementCnt = 2;
4535    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4536    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4537    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4538    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4539    {
4540       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4541       return RFAILED;
4542    }
4543
4544    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4545    {
4546       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4547       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4548       {
4549           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4550           return RFAILED;
4551       }
4552    }
4553
4554    arrIdx = 0;
4555    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4556    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4557
4558    return ROK;
4559 }
4560
4561 /*******************************************************************
4562  *
4563  * @brief Fills SRS resource to add/modify list
4564  *
4565  * @details
4566  *
4567  *    Function : BuildSrsRsrcAddModList
4568  *
4569  *    Functionality: Fills SRS resource to add/modify list
4570  *
4571  * @params[in]
4572  * @return ROK     - success
4573  *         RFAILED - failure
4574  *
4575  * ****************************************************************/
4576 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4577 {
4578    uint8_t   elementCnt;
4579    uint8_t   rsrcIdx;
4580
4581    elementCnt = 1;
4582    resourceList->list.count = elementCnt;
4583    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4584    resourceList->list.array = NULLP;
4585    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4586    if(!resourceList->list.array)
4587    {
4588       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4589       return RFAILED;
4590    }
4591
4592    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4593    {
4594       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4595       if(!resourceList->list.array[rsrcIdx])
4596       {
4597          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4598          return RFAILED;
4599       }
4600    }
4601
4602    rsrcIdx = 0;
4603    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4604    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4605    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4606
4607    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4608    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4609          sizeof(struct SRS_Resource__transmissionComb__n2));
4610    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4611    {
4612       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4613       return RFAILED;
4614    }
4615    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4616       = SRS_COMB_OFFSET_N2;
4617    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4618       = SRS_CYCLIC_SHIFT_N2;
4619
4620    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4621    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4622                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4623    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4624                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4625
4626    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4627    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4628    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4629    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4630    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4631    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4632                                                                SRS_Resource__groupOrSequenceHopping_neither;
4633
4634    /* Setting resource type to aperiodic for intergration purposes */
4635    resourceList->list.array[rsrcIdx]->resourceType.present = \
4636                                                              SRS_Resource__resourceType_PR_aperiodic;
4637    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4638    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4639          sizeof(struct SRS_Resource__resourceType__aperiodic));
4640    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4641    {
4642       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4643       return RFAILED;
4644    }
4645    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4646
4647    return ROK;
4648 }
4649
4650 /*******************************************************************
4651  *
4652  * @brief Build SRS resource set Add/mod list
4653  *
4654  * @details
4655  *
4656  *    Function : BuildSrsRsrcSetAddModList
4657  *
4658  *    Functionality: Build SRS resource set Add/mod list
4659  *
4660  * @params[in]
4661  * @return ROK     - success
4662  *         RFAILED - failure
4663  *
4664  * ****************************************************************/
4665    uint8_t BuildSrsRsrcSetAddModList
4666 (
4667  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4668  )
4669 {
4670    uint8_t  elementCnt;
4671    uint8_t  rSetIdx;
4672    uint8_t  rsrcIdx;
4673    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4674
4675    elementCnt = 1;
4676    rsrcSetList->list.count = elementCnt;
4677    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4678    rsrcSetList->list.array = NULLP;
4679    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4680    if(!rsrcSetList->list.array)
4681    {
4682       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4683       return RFAILED;
4684    }
4685
4686    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4687    {
4688       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4689       if(!rsrcSetList->list.array[rSetIdx])
4690       {
4691          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4692          return RFAILED;
4693       }
4694    }
4695
4696    rSetIdx = 0;
4697    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4698
4699    /* Fill Resource Id list in resource set */
4700    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4701    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4702          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4703    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4704    {
4705       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4706       return RFAILED;
4707    }
4708
4709    elementCnt = 1;
4710    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4711    rsrcIdList->list.count = elementCnt;
4712    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4713    rsrcIdList->list.array = NULLP;
4714    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4715    if(!rsrcIdList->list.array)
4716    {
4717       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4718       return RFAILED;
4719    }
4720
4721    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4722    {
4723       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4724       if(!rsrcIdList->list.array[rsrcIdx])
4725       {
4726          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4727          return RFAILED;
4728       }
4729    }
4730
4731    rsrcIdx = 0;
4732    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4733
4734    /* Fill resource type */
4735    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4736                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4737
4738    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4739    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4740          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4741    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4742    {
4743       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4744       return RFAILED;
4745    }
4746    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4747       = APERIODIC_SRS_RESRC_TRIGGER;
4748
4749    /* TODO : Fill values for below IEs as expected by Viavi */
4750    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4751    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4752
4753
4754    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4755    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4756    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4757    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4758    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4759
4760    return ROK;
4761 }
4762
4763 /*******************************************************************
4764  *
4765  * @brief Builds BWP UL dedicated SRS Config
4766  *
4767  * @details
4768  *
4769  *    Function : BuildBWPUlDedSrsCfg
4770  *
4771  *    Functionality: Builds BWP UL dedicated SRS Config
4772  *
4773  * @params[in] SRS Config
4774  * @return ROK     - success
4775  *         RFAILED - failure
4776  *
4777  * ****************************************************************/
4778 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4779 {
4780    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4781    srsCfg->srs_ResourceSetToAddModList = NULLP;
4782    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4783          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4784    if(!srsCfg->srs_ResourceSetToAddModList)
4785    {
4786       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4787       return RFAILED;
4788    }
4789    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4790    {
4791       return RFAILED;
4792    }
4793
4794    srsCfg->srs_ResourceToReleaseList = NULLP;
4795
4796    /* Resource to Add/Modify list */
4797    srsCfg->srs_ResourceToAddModList = NULLP;
4798    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4799          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4800    if(!srsCfg->srs_ResourceToAddModList)
4801    {
4802       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4803       return RFAILED;
4804    }
4805
4806    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4807    {
4808       return RFAILED;
4809    }
4810
4811    srsCfg->tpc_Accumulation = NULLP;
4812
4813    return ROK;
4814 }
4815
4816 /*******************************************************************
4817  *
4818  * @brief Builds inital UL BWP
4819  *
4820  * @details
4821  *
4822  *    Function : BuildInitialUlBWP
4823  *
4824  *    Functionality: Builds initial UL BWP
4825  *
4826  * @params[in] BWP_UplinkDedicated_t *ulBwp
4827  * @return ROK     - success
4828  *         RFAILED - failure
4829  *
4830  * ****************************************************************/
4831 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4832 {
4833    ulBwp->pucch_Config = NULLP;
4834    ulBwp->pucch_Config = NULLP;
4835    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4836    if(!ulBwp->pucch_Config)
4837    {
4838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4839       return RFAILED;
4840    }
4841
4842    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4843    ulBwp->pucch_Config->choice.setup = NULLP;
4844    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4845    if(!ulBwp->pucch_Config->choice.setup)
4846    {
4847       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4848       return RFAILED;
4849    }
4850
4851    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4852    {
4853       return RFAILED;
4854    }
4855
4856    /* Fill BWP UL dedicated PUSCH config */
4857    ulBwp->pusch_Config = NULLP;
4858    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4859    if(!ulBwp->pusch_Config)
4860    {
4861       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4862       return RFAILED;
4863    }
4864
4865    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4866    ulBwp->pusch_Config->choice.setup = NULLP;
4867    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4868    if(!ulBwp->pusch_Config->choice.setup)
4869    {
4870       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4871       return RFAILED;
4872    }
4873
4874    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4875    {
4876       return RFAILED;
4877    }
4878
4879    ulBwp->configuredGrantConfig = NULLP;
4880
4881    /* Fill BPW UL dedicated SRS config */
4882    ulBwp->srs_Config = NULLP;
4883    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4884    if(!ulBwp->srs_Config)
4885    {
4886       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4887       return RFAILED;
4888    }
4889
4890    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4891    ulBwp->srs_Config->choice.setup = NULLP;
4892    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4893    if(!ulBwp->srs_Config->choice.setup)
4894    {
4895       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4896       return RFAILED;
4897    }
4898
4899    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4900    {
4901       return RFAILED;
4902    }
4903
4904    ulBwp->beamFailureRecoveryConfig = NULLP;
4905
4906    return ROK;
4907 }
4908
4909 /*******************************************************************
4910  *
4911  * @brief Builds Pusch Serving cell Config
4912  *
4913  * @details
4914  *
4915  *    Function : BuildPuschSrvCellCfg
4916  *
4917  *    Functionality: Builds Pusch Serving cell Config
4918  *
4919  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4920  *
4921  * @return ROK     - success
4922  *         RFAILED - failure
4923  *
4924  * ****************************************************************/
4925 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4926 {
4927    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4928    puschCfg->choice.setup = NULLP;
4929    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4930    if(!puschCfg->choice.setup)
4931    {
4932       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4933       return RFAILED;
4934    }
4935
4936    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4937    puschCfg->choice.setup->rateMatching = NULLP;
4938    puschCfg->choice.setup->xOverhead = NULLP;
4939    puschCfg->choice.setup->ext1 = NULLP;
4940    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4941    if(!puschCfg->choice.setup->ext1)
4942    {
4943       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4944       return RFAILED;
4945    }
4946
4947    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4948    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4949    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4950    {
4951       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4952       return RFAILED;
4953    }
4954    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4955
4956    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4957    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4958    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4959    {
4960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4961       return RFAILED;
4962    }
4963    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4964    return ROK;
4965 }
4966
4967 /*******************************************************************
4968  *
4969  * @brief Builds UL config
4970  * @details
4971  *
4972  *    Function : BuildUlCfg
4973  *
4974  *    Functionality: Builds UL config in spCellCfgDed
4975  *
4976  * @params[in] UplinkConfig_t *ulCfg
4977  *
4978  * @return ROK     - success
4979  *         RFAILED - failure
4980  *
4981  * ****************************************************************/
4982 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4983 {
4984    ulCfg->initialUplinkBWP = NULLP;
4985    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4986    if(!ulCfg->initialUplinkBWP)
4987    {
4988       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4989       return RFAILED;
4990    }
4991
4992    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4993    {
4994       return RFAILED;
4995    }
4996
4997    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4998    ulCfg->uplinkBWP_ToAddModList = NULLP;
4999    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5000    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5001    if(!ulCfg->firstActiveUplinkBWP_Id)
5002    {
5003       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5004       return RFAILED;
5005    }
5006    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5007
5008    ulCfg->pusch_ServingCellConfig = NULLP;
5009    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
5010          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5011    if(!ulCfg->pusch_ServingCellConfig)
5012    {
5013       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5014       return RFAILED;
5015    }
5016
5017    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5018    {
5019       return RFAILED;
5020    }
5021
5022    ulCfg->carrierSwitching = NULLP;
5023    ulCfg->ext1 = NULLP;
5024    return ROK;
5025 }
5026
5027 /*******************************************************************
5028  *
5029  * @brief Builds PDSCH serving cell config
5030  * @details
5031  *
5032  *    Function : BuildPdschSrvCellCfg
5033  *
5034  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5035  *
5036  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5037  *
5038  * @return ROK     - success
5039  *         RFAILED - failure
5040  *
5041  * ****************************************************************/
5042 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5043 {
5044    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5045    pdschCfg->choice.setup = NULLP;
5046    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5047    if(!pdschCfg->choice.setup)
5048    {
5049       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5050       return RFAILED;
5051    }
5052
5053    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5054    pdschCfg->choice.setup->xOverhead = NULLP;
5055    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5056    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5057    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5058    {
5059       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5060       return RFAILED;
5061    }
5062    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5063    pdschCfg->choice.setup->pucch_Cell = NULLP;
5064    pdschCfg->choice.setup->ext1 = NULLP;
5065
5066    return ROK;
5067 }
5068
5069 /*******************************************************************
5070  *
5071  * @brief Builds CSI Meas config
5072  * @details
5073  *
5074  *    Function : BuildCsiMeasCfg
5075  *
5076  *    Functionality: Builds CSI Meas config in spCellCfgDed
5077  *
5078  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5079  *
5080  * @return ROK     - success
5081  *         RFAILED - failure
5082  *
5083  * ****************************************************************/
5084 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5085 {
5086
5087    return ROK;
5088 }
5089
5090 /*******************************************************************
5091  *
5092  * @brief Builds Spcell config dedicated
5093  * @details
5094  *
5095  *    Function : BuildSpCellCfgDed
5096  *
5097  *    Functionality: Builds sp cell config dedicated in spCellCfg
5098  *
5099  * @params[in] ServingCellConfig_t srvCellCfg
5100  *
5101  * @return ROK     - success
5102  *         RFAILED - failure
5103  *
5104  * ****************************************************************/
5105 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5106 {
5107    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5108
5109    srvCellCfg->initialDownlinkBWP = NULLP;
5110    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5111    if(!srvCellCfg->initialDownlinkBWP)
5112    {
5113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5114       return RFAILED;
5115    }
5116
5117    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5118    {
5119       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5120       return RFAILED;
5121    }
5122    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5123    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5124
5125    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5126    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5127    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5128    {
5129       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5130       return RFAILED;
5131    }
5132    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5133
5134    srvCellCfg->bwp_InactivityTimer = NULLP;
5135
5136    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5137    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5138    if(!srvCellCfg->defaultDownlinkBWP_Id)
5139    {
5140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5141       return RFAILED;
5142    }
5143    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5144
5145    srvCellCfg->uplinkConfig = NULLP;
5146    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5147    if(!srvCellCfg->uplinkConfig)
5148    {
5149       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5150       return RFAILED;
5151    }
5152
5153    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5154    {
5155       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5156       return RFAILED;
5157    }
5158    srvCellCfg->supplementaryUplink = NULLP;
5159    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5160
5161    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5162    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5163    if(!srvCellCfg->pdsch_ServingCellConfig)
5164    {
5165       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5166       return RFAILED;
5167    }
5168
5169    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5170    {
5171       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5172       return RFAILED;
5173    }
5174
5175    srvCellCfg->csi_MeasConfig = NULLP;
5176 #if 0
5177    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5178       if(!srvCellCfg->csi_MeasConfig)
5179       {
5180          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5181          return RFAILED;
5182       }
5183
5184    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5185    {
5186       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5187       return RFAILED;
5188    }
5189 #endif
5190    srvCellCfg->sCellDeactivationTimer = NULLP;
5191    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5192    srvCellCfg->tag_Id = TAG_ID;
5193    srvCellCfg->dummy = NULLP;
5194    srvCellCfg->pathlossReferenceLinking = NULLP;
5195    srvCellCfg->servingCellMO = NULLP;
5196    srvCellCfg->ext1 = NULLP;
5197
5198    return ROK;
5199 }
5200 /*******************************************************************
5201  *
5202  * @brief Builds Spcell config
5203  *
5204  * @details
5205  *
5206  *    Function : BuildSpCellCfg
5207  *
5208  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5209  *
5210  * @params[in] SpCellConfig_t spCellCfg
5211  *
5212  * @return ROK     - success
5213  *         RFAILED - failure
5214  *
5215  * ****************************************************************/
5216 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5217 {
5218
5219    spCellCfg->servCellIndex = NULLP;
5220    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5221    if(!spCellCfg->servCellIndex)
5222    {
5223       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5224       return RFAILED;
5225    }
5226    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5227
5228    spCellCfg->reconfigurationWithSync = NULLP;
5229    spCellCfg->rlf_TimersAndConstants = NULLP;
5230    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5231    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5232    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5233    {
5234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5235       return RFAILED;
5236    }
5237    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5238
5239    spCellCfg->spCellConfigDedicated = NULLP;
5240    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5241    if(!spCellCfg->spCellConfigDedicated)
5242    {
5243       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5244       return RFAILED;
5245    }
5246    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5247    {
5248       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5249       return RFAILED;
5250    }
5251    return ROK;
5252 }
5253 /*******************************************************************
5254  *
5255  * @brief Builds Phy cell group config
5256  *
5257  * @details
5258  *
5259  *    Function : BuildPhyCellGrpCfg
5260  *
5261  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5262  *
5263  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5264  *
5265  * @return ROK     - success
5266  *         RFAILED - failure
5267  *
5268  * ****************************************************************/
5269 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5270 {
5271    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5272    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5273
5274    phyCellGrpCfg->p_NR_FR1 = NULLP;
5275    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5276    if(!phyCellGrpCfg->p_NR_FR1)
5277    {
5278       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5279       return RFAILED;
5280    }
5281    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5282    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5283    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5284    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5285    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5286    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5287    phyCellGrpCfg->cs_RNTI = NULLP;
5288    phyCellGrpCfg->ext1 = NULLP;
5289    phyCellGrpCfg->ext2 = NULLP;
5290
5291    return ROK;
5292 }
5293
5294 /*******************************************************************
5295  *
5296  * @brief Builds tag config
5297  *
5298  * @details
5299  *
5300  *    Function : BuildTagConfig
5301  *
5302  *    Functionality: Builds tag config in MacCellGroupConfig
5303  *
5304  * @params[in] TAG_Config *tag_Config
5305  *
5306  * @return ROK     - success
5307  *         RFAILED - failure
5308  *
5309  * ****************************************************************/
5310 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5311 {
5312    struct TAG_Config__tag_ToAddModList *tagList;
5313    uint8_t                     idx, elementCnt;
5314
5315    tagConfig->tag_ToReleaseList = NULLP;
5316    tagConfig->tag_ToAddModList = NULLP;
5317    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5318    if(!tagConfig->tag_ToAddModList)
5319    {
5320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5321       return RFAILED;
5322    }
5323
5324    elementCnt = 1; //ODU_VALUE_ONE;
5325    tagList = tagConfig->tag_ToAddModList;
5326    tagList->list.count = elementCnt;
5327    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5328
5329    tagList->list.array = NULLP;
5330    CU_ALLOC(tagList->list.array, tagList->list.size);
5331    if(!tagList->list.array)
5332    {
5333       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5334       return RFAILED;
5335    }
5336
5337    for(idx=0; idx<tagList->list.count; idx++)
5338    {
5339       tagList->list.array[idx] = NULLP;
5340       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5341       if(!tagList->list.array[idx])
5342       {
5343          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5344          return RFAILED;
5345       }
5346    }
5347
5348    idx = 0;
5349    tagList->list.array[idx]->tag_Id = TAG_ID;
5350    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5351
5352    return ROK;
5353 }
5354
5355 /*******************************************************************
5356  *
5357  * @brief Builds PHR Config
5358  *
5359  * @details
5360  *
5361  *    Function : BuildPhrConfig
5362  *
5363  *    Functionality: Builds phrConfig in MacCellGroupConfig
5364  *
5365  * @params[in] PHR Config *
5366  *
5367  * @return ROK     - success
5368  *         RFAILED - failure
5369  *
5370  * ****************************************************************/
5371 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5372 {
5373
5374    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5375    phrConfig->choice.setup = NULLP;
5376    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5377    if(!phrConfig->choice.setup)
5378    {
5379       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5380       return RFAILED;
5381    }
5382
5383    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5384    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5385    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5386    phrConfig->choice.setup->multiplePHR              = false;
5387    phrConfig->choice.setup->dummy                    = false;
5388    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5389    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5390
5391    return ROK;
5392 }
5393
5394 /*******************************************************************
5395  *
5396  * @brief Builds BSR Config
5397  *
5398  * @details
5399  *
5400  *    Function : BuildBsrConfig
5401  *
5402  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5403  *
5404  * @params[in] BSR_Config *bsrConfig
5405  *
5406  * @return ROK     - success
5407  *         RFAILED - failure
5408  *
5409  * ****************************************************************/
5410 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5411 {
5412    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5413    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5414    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5415
5416    return ROK;
5417 }
5418
5419 /*******************************************************************
5420  *
5421  * @brief Builds scheduling request config
5422  *
5423  * @details
5424  *
5425  *    Function : BuildSchedulingReqConfig
5426  *
5427  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5428  *
5429  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5430  *
5431  * @return ROK     - success
5432  *         RFAILED - failure
5433  *
5434  * ****************************************************************/
5435 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5436 {
5437    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5438    uint8_t                     idx, elementCnt;
5439
5440    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5441    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5442          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5443    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5444    {
5445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5446       return RFAILED;
5447    }
5448
5449    elementCnt = 1; //ODU_VALUE_ONE;
5450    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5451    schReqList->list.count = elementCnt;
5452    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5453
5454    schReqList->list.array = NULLP;
5455    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5456    if(!schReqList->list.array)
5457    {
5458       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5459       return RFAILED;
5460    }
5461
5462    for(idx=0;idx<schReqList->list.count; idx++)
5463    {
5464       schReqList->list.array[idx] = NULLP;
5465       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5466       if(!schReqList->list.array[idx])
5467       {
5468          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5469          return RFAILED;
5470       }
5471    }
5472
5473    idx = 0;
5474    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5475
5476    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5477    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5478    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5479    {
5480       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5481       return RFAILED;
5482    }
5483    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5484    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5485    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5486
5487    return ROK;
5488 }
5489 /*******************************************************************
5490  *
5491  * @brief Builds Mac cell group config
5492  *
5493  * @details
5494  *
5495  *    Function : BuildMacCellGrpCfg
5496  *
5497  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5498  *
5499  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5500  *
5501  * @return ROK     - success
5502  *         RFAILED - failure
5503  *
5504  * ****************************************************************/
5505 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5506 {
5507    macCellGrpCfg->drx_ConfigRrc = NULLP;
5508    macCellGrpCfg->schedulingRequestConfig = NULLP;
5509    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5510    if(!macCellGrpCfg->schedulingRequestConfig)
5511    {
5512       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5513       return RFAILED;
5514    }
5515
5516    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5517    {
5518       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5519       return RFAILED;
5520    }
5521
5522    macCellGrpCfg->bsr_Config = NULLP;
5523    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5524    if(!macCellGrpCfg->bsr_Config)
5525    {
5526       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5527       return RFAILED;
5528    }
5529
5530    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5531    {
5532       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5533       return RFAILED;
5534    }
5535
5536    macCellGrpCfg->tag_Config = NULLP;
5537    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5538    if(!macCellGrpCfg->tag_Config)
5539    {
5540       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5541       return RFAILED;
5542    }
5543
5544    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5545    {
5546       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5547       return RFAILED;
5548    }
5549
5550    macCellGrpCfg->phr_Config = NULLP;
5551    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5552    if(!macCellGrpCfg->phr_Config)
5553    {
5554       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5555       return RFAILED;
5556    }
5557
5558    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5559    {
5560       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5561       return RFAILED;
5562    }
5563
5564    macCellGrpCfg->skipUplinkTxDynamic = false;
5565    macCellGrpCfg->ext1 = NULLP;
5566
5567    return ROK;
5568 }
5569 /*******************************************************************
5570  *
5571  * @brief Frees memeory allocated for SearchSpcToAddModList
5572  *
5573  * @details
5574  *
5575  *    Function : FreeSearchSpcToAddModList
5576  *
5577  *    Functionality: Deallocating memory of SearchSpcToAddModList
5578  *
5579  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5580  *
5581  * @return void
5582  *
5583  4221 * ****************************************************************/
5584 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5585 {
5586    uint8_t idx1=0;
5587    uint8_t idx2=0;
5588    struct  SearchSpace *searchSpc=NULLP;
5589
5590    if(searchSpcList->list.array)
5591    {
5592       if(searchSpcList->list.array[idx2])
5593       {
5594          searchSpc = searchSpcList->list.array[idx2];
5595          if(searchSpc->controlResourceSetId)
5596          {
5597             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5598             {
5599                if(searchSpc->monitoringSymbolsWithinSlot)
5600                {
5601                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5602                   {
5603                      if(searchSpc->nrofCandidates)
5604                      {
5605                         if(searchSpc->searchSpaceType)
5606                         {
5607                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5608                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5609                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5610                                     SearchSpace__searchSpaceType));
5611                         }
5612                         CU_FREE(searchSpc->nrofCandidates,
5613                               sizeof(struct SearchSpace__nrofCandidates));
5614                      }
5615                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5616                            searchSpc->monitoringSymbolsWithinSlot->size);
5617                   }
5618                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5619                         sizeof(BIT_STRING_t));
5620                }
5621                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5622                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5623             }
5624             CU_FREE(searchSpc->controlResourceSetId,
5625                   sizeof(ControlResourceSetId_t));
5626          }
5627       }
5628       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5629       {
5630          CU_FREE(searchSpcList->list.array[idx1],
5631                sizeof(struct SearchSpace));
5632       }
5633       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5634    }
5635 }
5636 /*******************************************************************
5637  *
5638  * @brief Frees memory allocated for PdschTimeDomAllocList
5639  *
5640  * @details
5641  *
5642  *    Function : FreePdschTimeDomAllocList
5643  *
5644  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5645  *
5646  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5647  *
5648  * @return void
5649  *
5650  4221 * ****************************************************************/
5651 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5652 {
5653    uint8_t idx1=0;
5654
5655    if(timeDomAllocList->choice.setup)
5656    {
5657       if(timeDomAllocList->choice.setup->list.array)
5658       {
5659          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5660          {
5661             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5662                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5663          }
5664          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5665                timeDomAllocList->choice.setup->list.size);
5666       }
5667       CU_FREE(timeDomAllocList->choice.setup,\
5668             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5669    }
5670 }
5671 /*******************************************************************
5672  *
5673  * @brief Frees memory allocated for PuschTimeDomAllocList
5674  *
5675  *@details
5676  *
5677  *    Function : FreePuschTimeDomAllocList
5678  *
5679  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5680  *
5681  * @params[in] PUSCH_Config_t *puschCfg
5682  *
5683  * @return void
5684  *
5685  ***********************************************************************/
5686 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5687 {
5688    uint8_t idx1=0;
5689    uint8_t idx2=0;
5690    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5691
5692    if(puschCfg->pusch_TimeDomainAllocationList)
5693    {
5694       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5695       if(timeDomAllocList_t->choice.setup)
5696       {
5697          if(timeDomAllocList_t->choice.setup->list.array)
5698          {
5699             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5700             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5701             {
5702                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5703                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5704             }
5705             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5706                   timeDomAllocList_t->choice.setup->list.size);
5707          }
5708          CU_FREE(timeDomAllocList_t->choice.setup, \
5709                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5710       }
5711       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5712       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5713             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5714    }
5715
5716 }
5717
5718 /*******************************************************************
5719  *
5720  * @brief Frees memory allocated for Dedicated PUCCH config
5721  *
5722  * @details
5723  *
5724  *    Function : FreeBWPUlDedPucchCfg
5725  *
5726  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5727  *
5728  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5729  *
5730  * @return void
5731  *
5732  * ****************************************************************/
5733 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5734 {
5735    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5736    PUCCH_Config_t *pucchCfg = NULLP;
5737    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5738    PUCCH_Resource_t *rsrc = NULLP;
5739
5740    if(ulBwpPucchCfg)
5741    {
5742       if(ulBwpPucchCfg->choice.setup)
5743       {
5744          pucchCfg = ulBwpPucchCfg->choice.setup;
5745
5746          //Free resource set list
5747          if(pucchCfg->resourceSetToAddModList)
5748          {
5749             if(pucchCfg->resourceSetToAddModList->list.array)
5750             {
5751                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5752                {
5753                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5754                   if(rsrcSet->resourceList.list.array)
5755                   {
5756                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5757                      {
5758                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5759                      }
5760                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5761                   }
5762                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5763                }
5764                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5765             }
5766             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5767          }
5768
5769          //Free resource list
5770          if(pucchCfg->resourceToAddModList)
5771          {
5772             if(pucchCfg->resourceToAddModList->list.array)
5773             {
5774                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5775                {
5776                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5777                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5778                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5779                }
5780                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5781             }
5782             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5783          }
5784
5785          //PUCCH Format 1
5786          if(pucchCfg->format1)
5787          {
5788             if(pucchCfg->format1->choice.setup)
5789             {
5790                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5791                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5792             }
5793             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5794          }
5795
5796          //DL DATA TO UL ACK
5797          if(pucchCfg->dl_DataToUL_ACK)
5798          {
5799             if(pucchCfg->dl_DataToUL_ACK->list.array)
5800             {
5801                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5802                {
5803                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5804                }
5805                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5806             }
5807             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5808          }
5809
5810          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5811       }
5812       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5813    }
5814 }
5815
5816 /*******************************************************************
5817  *
5818  * @brief Frees memory allocated for InitialUlBWP
5819  *
5820  * @details
5821  *
5822  *    Function : FreeInitialUlBWP
5823  *
5824  *    Functionality: Deallocating memory of InitialUlBWP
5825  *
5826  * @params[in] BWP_UplinkDedicated_t *ulBwp
5827  *
5828  * @return void
5829  *
5830  * ****************************************************************/
5831 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5832 {
5833    uint8_t  rSetIdx, rsrcIdx;
5834    SRS_Config_t   *srsCfg = NULLP;
5835    PUSCH_Config_t *puschCfg = NULLP;
5836    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5837    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5838    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5839    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5840
5841    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5842
5843    if(ulBwp->pusch_Config)
5844    {
5845       if(ulBwp->pusch_Config->choice.setup)
5846       {
5847          puschCfg=ulBwp->pusch_Config->choice.setup;
5848          if(puschCfg->dataScramblingIdentityPUSCH)
5849          {
5850             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5851             {
5852                FreePuschTimeDomAllocList(puschCfg);
5853                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5854                if(dmrsUlCfg->choice.setup)
5855                {
5856                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5857                   {
5858                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5859                      {
5860                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5861                               sizeof(long));
5862                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5863                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5864                      }
5865                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5866                            sizeof(long));
5867                   }
5868                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5869                }
5870                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5871                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5872             }
5873             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5874          }
5875          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5876       }
5877       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5878
5879       /* Free SRS-Config */
5880       if(ulBwp->srs_Config)
5881       {
5882          if(ulBwp->srs_Config->choice.setup)
5883          {
5884             srsCfg = ulBwp->srs_Config->choice.setup;
5885
5886             /* Free Resource Set to add/mod list */
5887             if(srsCfg->srs_ResourceSetToAddModList)
5888             {
5889                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5890                if(rsrcSetList->list.array)
5891                {
5892                   rSetIdx = 0;
5893
5894                   /* Free SRS resource Id list in this SRS resource set */
5895                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5896                   {
5897                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5898
5899                      if(rsrcIdList->list.array)
5900                      {
5901                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5902                         {
5903                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5904                         }
5905                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5906                      }
5907                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5908                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5909                   }
5910
5911                   /* Free resource type info for this SRS resource set */
5912                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5913                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5914
5915                   /* Free memory for each resource set */
5916                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5917                   {
5918                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5919                   }
5920                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5921                }
5922                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5923                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5924             }
5925
5926             /* Free resource to add/modd list */
5927             if(srsCfg->srs_ResourceToAddModList)
5928             {
5929                resourceList = srsCfg->srs_ResourceToAddModList;
5930                if(resourceList->list.array)
5931                {
5932                   rsrcIdx = 0;
5933                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5934                         sizeof(struct SRS_Resource__transmissionComb__n2));
5935                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5936                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5937
5938                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5939                   {
5940                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5941                   }
5942                   CU_FREE(resourceList->list.array, resourceList->list.size);
5943                }
5944                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5945                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5946             }
5947
5948             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5949          }
5950          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5951       }
5952    }
5953 }
5954 /*******************************************************************
5955  *
5956  * @brief Frees memory allocated for initialUplinkBWP
5957  *
5958  * @details
5959  *
5960  *    Function : FreeinitialUplinkBWP
5961  *
5962  *    Functionality: Deallocating memory of initialUplinkBWP
5963  *
5964  * @params[in] UplinkConfig_t *ulCfg
5965  *
5966  * @return void
5967  *
5968  *
5969  * ****************************************************************/
5970 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5971 {
5972    BWP_UplinkDedicated_t *ulBwp=NULLP;
5973    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5974
5975    if(ulCfg->initialUplinkBWP)
5976    {
5977       ulBwp=ulCfg->initialUplinkBWP;
5978       if(ulCfg->firstActiveUplinkBWP_Id)
5979       {
5980          if(ulCfg->pusch_ServingCellConfig)
5981          {
5982             puschCfg=ulCfg->pusch_ServingCellConfig;
5983             if(puschCfg->choice.setup)
5984             {
5985                if(puschCfg->choice.setup->ext1)
5986                {
5987                   CU_FREE(puschCfg->choice.setup->ext1->\
5988                         processingType2Enabled,sizeof(BOOLEAN_t));
5989                   CU_FREE(puschCfg->choice.setup->ext1->\
5990                         maxMIMO_Layers,sizeof(long));
5991                   CU_FREE(puschCfg->choice.setup->ext1, \
5992                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5993                }
5994                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5995             }
5996             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5997          }
5998          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5999       }
6000       FreeInitialUlBWP(ulBwp);
6001       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6002    }
6003 }
6004 /*******************************************************************
6005  *
6006  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6007  *
6008  * @details
6009  *
6010  *    Function : FreeBWPDlDedPdschCfg
6011  *
6012  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6013  *
6014  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6015  *
6016  * @return void
6017  *
6018  *
6019  * ****************************************************************/
6020 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6021 {
6022    struct PDSCH_Config *pdschCfg=NULLP;
6023    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6024    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6025    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6026
6027    if(dlBwp->pdsch_Config->choice.setup)
6028    {
6029       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6030       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6031       {
6032          if(pdschCfg->pdsch_TimeDomainAllocationList)
6033          {
6034             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6035             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6036             {
6037                prbBndlType=&pdschCfg->prb_BundlingType;
6038                CU_FREE(prbBndlType->choice.staticBundling,\
6039                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6040                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6041             }
6042             FreePdschTimeDomAllocList(timeDomAllocList);
6043             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6044                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6045          }
6046          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6047          if(dmrsDlCfg->choice.setup)
6048          {
6049             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6050                   sizeof(long));
6051             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6052          }
6053          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6054                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6055       }
6056       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6057    }
6058 }
6059 /*******************************************************************
6060  *
6061  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6062  *
6063  * @details
6064  *
6065  *    Function : FreeBWPDlDedPdcchCfg
6066  *
6067  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6068  *
6069  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6070  *
6071  * @return void
6072  *
6073  *
6074  * ****************************************************************/
6075 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6076 {
6077    uint8_t idx1=0;
6078    uint8_t idx2=0;
6079    struct PDCCH_Config *pdcchCfg=NULLP;
6080    struct ControlResourceSet *controlRSet=NULLP;
6081    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6082
6083    if(dlBwp->pdcch_Config->choice.setup)
6084    {
6085       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6086       if(pdcchCfg->controlResourceSetToAddModList)
6087       {
6088          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6089          if(controlRSetList->list.array)
6090          {
6091             controlRSet = controlRSetList->list.array[idx2];
6092             if(controlRSet)
6093             {
6094                if(controlRSet->frequencyDomainResources.buf)
6095                {
6096                   if(controlRSet->pdcch_DMRS_ScramblingID)
6097                   {
6098                      if(pdcchCfg->searchSpacesToAddModList)
6099                      {
6100                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6101                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
6102                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6103                      }
6104                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6105                   }
6106                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
6107                         controlRSet->frequencyDomainResources.size);
6108                }
6109             }
6110             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6111             {
6112                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6113             }
6114             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6115          }
6116          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6117                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6118       }
6119       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6120    }
6121 }
6122 /*******************************************************************
6123  *
6124  * @brief Builds RLC Config
6125  *
6126  * @details
6127  *
6128  *    Function : BuildRlcConfig
6129  *
6130  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
6131  *
6132  * @params[in] RLC_Config *rlcConfig
6133  *
6134  * @return ROK     - success
6135  *         RFAILED - failure
6136  *
6137  * ****************************************************************/
6138 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
6139 {
6140    rlcConfig->present = rlcLcCfgDb.rlcMode;
6141
6142    switch(rlcConfig->present)
6143    {
6144       case RLC_Config_PR_am:
6145          {
6146             rlcConfig->choice.am = NULLP;
6147             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6148             if(!rlcConfig->choice.am)
6149             {
6150                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6151                return RFAILED;
6152             }
6153
6154             /* UL */
6155             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
6156             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6157             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
6158             {
6159                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6160                return RFAILED;
6161             }
6162             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
6163             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
6164             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
6165             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
6166             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
6167
6168             /* DL */
6169             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
6170             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6171             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
6172             {
6173                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6174                return RFAILED;
6175             }
6176             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
6177             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
6178             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
6179
6180             break;
6181          }
6182
6183       case RLC_Config_PR_um_Bi_Directional:
6184          {
6185             rlcConfig->choice.um_Bi_Directional = NULLP;
6186             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
6187             if(!rlcConfig->choice.um_Bi_Directional)
6188             {
6189                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6190                return RFAILED;
6191             }
6192
6193             /* UL */
6194             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
6195             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6196             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
6197             {
6198                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6199                return RFAILED;
6200             }
6201             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
6202
6203             /* DL */
6204             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
6205             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
6206             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
6207             {
6208                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
6209                return RFAILED;
6210             }
6211             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
6212             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
6213             break;
6214          }
6215    }
6216    return ROK;
6217 }
6218
6219 /*******************************************************************
6220  *
6221  * @brief Builds MAC LC Config
6222  *
6223  * @details
6224  *
6225  *    Function : BuildMacLCConfig
6226  *
6227  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
6228  *
6229  * @params[in] struct LogicalChannelConfig macLcConfig
6230  *
6231  * @return ROK     - success
6232  *         RFAILED - failure
6233  *
6234  * ****************************************************************/
6235 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6236 {
6237
6238    macLcConfig->ul_SpecificParameters = NULLP;
6239    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6240    if(!macLcConfig->ul_SpecificParameters)
6241    {
6242       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6243       return RFAILED;
6244    }
6245
6246    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6247    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6248    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6249    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6250    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6251    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6252    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6253
6254    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6255    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6256    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6257    {
6258       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6259       return RFAILED;
6260    }
6261    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6262
6263    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6264    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6265    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6266    {
6267       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6268       return RFAILED;
6269    }
6270    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6271
6272    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6273    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6274    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6275
6276    return ROK;
6277 }
6278 /*******************************************************************
6279  *
6280  * @brief Builds RLC Bearer to Add/Mod list
6281  *
6282  * @details
6283  *
6284  *    Function :BuildRlcBearerToAddModList
6285  *
6286  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6287  *
6288  * @params[in] rlc_BearerToAddModList
6289  *
6290  * @return ROK     - success
6291  *         RFAILED - failure
6292  *
6293  * ****************************************************************/
6294 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6295 {
6296    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6297
6298    if(updateAllRbCfg)
6299       elementCnt = ueCb->numSrb + ueCb->numDrb;
6300    else
6301    {
6302       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6303       {
6304          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6305             elementCnt++;
6306       }
6307
6308       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6309       {
6310          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6311             elementCnt++;
6312       }
6313    }
6314
6315    if(!elementCnt)
6316    {
6317       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6318       return ROK;
6319    }
6320    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6321    if(!rlcBearerList)
6322    {
6323       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6324       return RFAILED;
6325    }
6326    rlcBearerList->list.count = elementCnt;
6327    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6328
6329    rlcBearerList->list.array = NULLP;
6330    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6331    if(!rlcBearerList->list.array)
6332    {
6333       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6334       return RFAILED;
6335    }
6336
6337    for(idx=0; idx<rlcBearerList->list.count; idx++)
6338    {
6339       rlcBearerList->list.array[idx] = NULLP;
6340       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6341       if(!rlcBearerList->list.array[idx])
6342       {
6343          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6344          return RFAILED;
6345       }
6346    }
6347
6348    idx = 0;
6349
6350    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6351    {
6352       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6353          continue;
6354
6355       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6356
6357       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6358       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6359       {
6360          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6361          return RFAILED;
6362       }
6363
6364       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6365       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6366
6367       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6368       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6369       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6370       if(!rlcBearerList->list.array[idx]->rlc_Config)
6371       {
6372          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6373          return RFAILED;
6374       }
6375
6376       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6377       {
6378          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6379          return RFAILED;
6380       }
6381
6382       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6383       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6384       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6385       {
6386          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6387          return RFAILED;
6388       }
6389
6390       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6391       {
6392          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6393          return RFAILED;
6394       }
6395       idx++;
6396    }
6397
6398    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6399    {
6400       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6401          continue;
6402
6403       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6404
6405       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6406       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6407       {
6408          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6409          return RFAILED;
6410       }
6411
6412       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6413       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6414
6415       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6416       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6417       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6418       if(!rlcBearerList->list.array[idx]->rlc_Config)
6419       {
6420          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6421          return RFAILED;
6422       }
6423
6424       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6425       {
6426          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6427          return RFAILED;
6428       }
6429
6430       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6431       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6432       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6433       {
6434          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6435          return RFAILED;
6436       }
6437
6438       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6439       {
6440          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6441          return RFAILED;
6442       }
6443       idx++;
6444    }
6445    return ROK;
6446 }
6447
6448 /*******************************************************************
6449  *
6450  * @brief Free memory allocated for CellGroupConfig
6451  *
6452  * @details
6453  *
6454  *    Function : FreeMemCellGrpCfg
6455  *
6456  *    Functionality: Deallocating memory of CellGroupConfig
6457  *
6458  * @params[in] pointer to CellGroupConfigRrc_t
6459  *
6460  * @return ROK     - success
6461  *         RFAILED - failure
6462  *
6463  ******************************************************************/
6464 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6465 {
6466    uint8_t idx=0;
6467    SpCellConfig_t *spCellCfg=NULLP;
6468    ServingCellConfig_t *srvCellCfg=NULLP;
6469    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6470    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6471    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6472    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6473    struct RLC_Config *rlcConfig=NULLP;
6474    struct LogicalChannelConfig *macLcConfig=NULLP;
6475    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6476    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6477    struct TAG_Config *tagConfig=NULLP;
6478    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6479    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6480    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6481
6482    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6483    if(rlcBearerList)
6484    {
6485       if(rlcBearerList->list.array)
6486       {
6487          for(idx=0; idx<rlcBearerList->list.count; idx++)
6488          {
6489             if(rlcBearerList->list.array[idx])
6490             {
6491                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6492                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6493                if(rlcConfig)
6494                {
6495                   if(rlcConfig->choice.am)
6496                   {
6497                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6498                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6499                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6500                   }
6501                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6502                }
6503                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6504                if(macLcConfig)
6505                {
6506                   if(macLcConfig->ul_SpecificParameters)
6507                   {
6508                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6509                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6510                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6511                   }
6512                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6513                }
6514                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6515             }
6516          }
6517          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6518       }
6519       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6520    }
6521
6522    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6523    if(macCellGrpCfg)
6524    {
6525       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6526       if(schedulingRequestConfig)
6527       {
6528          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6529          if(schReqList)
6530          {
6531             if(schReqList->list.array)
6532             {
6533                for(idx=0;idx<schReqList->list.count; idx++)
6534                {
6535                   if(schReqList->list.array[idx])
6536                   {
6537                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6538                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6539                   }
6540                }
6541                CU_FREE(schReqList->list.array, schReqList->list.size);
6542             }
6543             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6544                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6545             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6546       }
6547       if(macCellGrpCfg->bsr_Config)
6548       {
6549          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6550       }
6551       tagConfig = macCellGrpCfg->tag_Config;
6552       if(tagConfig)
6553       {
6554          tagList = tagConfig->tag_ToAddModList;
6555          if(tagList)
6556          {
6557             if(tagList->list.array)
6558             {
6559                for(idx=0; idx<tagList->list.count; idx++)
6560                {
6561                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6562                }
6563                CU_FREE(tagList->list.array, tagList->list.size);
6564             }
6565             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6566          }
6567          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6568       }
6569
6570       phrConfig = macCellGrpCfg->phr_Config;
6571       if(phrConfig)
6572       {
6573          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6574          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6575       }
6576
6577       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6578    }
6579
6580    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6581    if(phyCellGrpCfg)
6582    {
6583       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6584       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6585    }
6586
6587    spCellCfg = cellGrpCfg->spCellConfig;
6588    if(spCellCfg)
6589    {
6590       if(spCellCfg->servCellIndex)
6591       {
6592          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6593          {
6594             if(spCellCfg->spCellConfigDedicated)
6595             {
6596                srvCellCfg = spCellCfg->spCellConfigDedicated;
6597                if(srvCellCfg->initialDownlinkBWP)
6598                {
6599                   dlBwp = srvCellCfg->initialDownlinkBWP;
6600                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6601                   {
6602                      if(srvCellCfg->defaultDownlinkBWP_Id)
6603                      {
6604                         if(srvCellCfg->uplinkConfig)
6605                         {
6606                            if(srvCellCfg->pdsch_ServingCellConfig)
6607                            {
6608                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6609                               if(pdschCfg->choice.setup)
6610                               {
6611                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6612                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6613                               }
6614                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6615                                        ServingCellConfig__pdsch_ServingCellConfig));
6616                            }
6617                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6618                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6619                         }
6620                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6621                      }
6622                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6623                   }
6624                   if(dlBwp->pdcch_Config)
6625                   {
6626                      if(dlBwp->pdsch_Config)
6627                      {
6628                         FreeBWPDlDedPdschCfg(dlBwp);
6629                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6630                      }
6631                      FreeBWPDlDedPdcchCfg(dlBwp);
6632                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6633                   }
6634                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6635                }
6636                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6637             }
6638             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6639          }
6640          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6641       }
6642       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6643    }
6644    return ROK;
6645 }
6646
6647 /*******************************************************************
6648  *
6649  * @brief Fills CellGroupConfig
6650  *
6651  * @details
6652  *
6653  *    Function : fillCellGrpCfg
6654  *
6655  *    Functionality: Fills CellGroupConfig
6656  *
6657  * @params[in] pointer to CellGroupConfigRrc_t
6658  *
6659  * @return ROK     - success
6660  *         RFAILED - failure
6661  *
6662  ******************************************************************/
6663
6664 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6665 {
6666    uint8_t               ret = RFAILED;
6667    CellGroupConfigRrc_t  cellGrpCfg;
6668    asn_enc_rval_t        encRetVal;
6669
6670    while(true)
6671    {
6672       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6673
6674       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6675
6676       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6677       {
6678          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6679          break;
6680       }
6681
6682       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6683       cellGrpCfg.mac_CellGroupConfig = NULLP;
6684       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6685       if(!cellGrpCfg.mac_CellGroupConfig)
6686       {
6687          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6688          break;
6689       }
6690       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6691       {
6692          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6693          break;
6694       }
6695
6696       cellGrpCfg.physicalCellGroupConfig = NULLP;
6697       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6698       if(!cellGrpCfg.physicalCellGroupConfig)
6699       {
6700          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6701          break;
6702       }
6703       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6704       {
6705          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6706          break;
6707       }
6708
6709       cellGrpCfg.spCellConfig = NULLP;
6710       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6711       if(!cellGrpCfg.spCellConfig)
6712       {
6713          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6714          break;
6715       }
6716       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6717       {
6718          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6719          break;
6720       }
6721
6722       cellGrpCfg.sCellToAddModList = NULLP;
6723       cellGrpCfg.sCellToReleaseList = NULLP;
6724       cellGrpCfg.ext1 = NULLP;
6725
6726       /* encode cellGrpCfg into duToCuRrcContainer */
6727       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6728       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6729       encBufSize = 0;
6730       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6731       /* Encode results */
6732       if(encRetVal.encoded == ENCODE_FAIL)
6733       {
6734          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6735                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6736          break;
6737       }
6738       else
6739       {
6740          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6741          for(int i=0; i< encBufSize; i++)
6742          {
6743             DU_LOG("%x",encBuf[i]);
6744          }
6745       }
6746
6747       cellGrp->size = encBufSize;
6748       CU_ALLOC(cellGrp->buf, cellGrp->size);
6749       if(!cellGrp->buf)
6750       {
6751          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6752          break;
6753       }
6754       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6755       ret = ROK;
6756       break;
6757    }
6758    FreeMemCellGrpCfg(&cellGrpCfg);
6759    return ret;
6760 }
6761
6762 /*******************************************************************
6763  *
6764  * @brief Free UE Capability RAT container
6765  *
6766  * @details
6767  *
6768  *    Function : freeUeCapRatCont
6769  *
6770  *    Functionality:
6771  *       Free UE Capability RAT conatiner
6772  *
6773  * @params[in]
6774  * @return ROK     - success
6775  *         RFAILED - failure
6776  *
6777  * ****************************************************************/
6778 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6779 {
6780    uint8_t idx;
6781    FeatureSets_t *featureSets;
6782
6783    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6784    {
6785       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6786       {
6787          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6788             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6789       }
6790       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6791    }
6792
6793    if(ueNrCap->featureSets)
6794    {
6795       featureSets = ueNrCap->featureSets;
6796       if(featureSets->featureSetsDownlinkPerCC)
6797       {
6798          if(featureSets->featureSetsDownlinkPerCC->list.array)
6799          {
6800             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6801             {
6802                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6803                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6804                         sizeof(ModulationOrder_t));
6805                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6806             }
6807             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6808          }
6809          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6810       }
6811
6812       if(featureSets->featureSetsUplinkPerCC)
6813       {
6814          if(featureSets->featureSetsUplinkPerCC->list.array)
6815          {
6816             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6817             {
6818                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6819                {
6820                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6821                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6822                          sizeof(ModulationOrder_t));
6823                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6824                }
6825             }
6826             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6827          }
6828          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6829       }
6830       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6831    }
6832 }
6833
6834 /*******************************************************************
6835  *
6836  * @brief Free UE capability RAT container list
6837  *
6838  * @details
6839  *
6840  *    Function : freeUeCapRatContList
6841  *
6842  *    Functionality: Free UE capability RAT container list
6843  *
6844  * @params[in]
6845  * @return ROK     - success
6846  *         RFAILED - failure
6847  *
6848  * ****************************************************************/
6849 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6850 {
6851    uint8_t idx;
6852    if(ueCapablityList->list.array)
6853    {
6854       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6855       {
6856          if(ueCapablityList->list.array[idx])
6857             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6858       }
6859       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6860    }
6861 }
6862
6863 /*******************************************************************
6864  *
6865  * @brief Free Handover preparation information
6866  *
6867  * @details
6868  *
6869  *    Function : freeHOPreparationInfo
6870  *
6871  *    Functionality: Free Handover preparation information
6872  *
6873  * @params[in]
6874  * @return ROK     - success
6875  *         RFAILED - failure
6876  *
6877  * ****************************************************************/
6878 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6879 {
6880    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6881
6882    if(hoPrep->criticalExtensions.choice.c1)
6883    {
6884       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6885       {
6886          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6887          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6888          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6889                sizeof(HandoverPreparationInformationRrc_IEs_t));
6890       }
6891       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6892    }
6893 }
6894
6895 /*******************************************************************
6896  *
6897  * @brief Fill feature sets
6898  *
6899  * @details
6900  *
6901  *    Function : fillFeatureSets
6902  *
6903  *    Functionality: Fill feature sets
6904  *
6905  * @params[in]
6906  * @return ROK     - success
6907  *         RFAILED - failure
6908  *
6909  * ****************************************************************/
6910 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6911 {
6912    uint8_t idx, elementCnt;
6913
6914    featureSets->featureSetsDownlink = NULLP;
6915    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6916    if(!featureSets->featureSetsDownlinkPerCC)
6917    {
6918       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6919       return RFAILED;
6920    }
6921
6922    elementCnt = 1;
6923    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6924    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6925    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6926    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6927    {
6928       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6929       return RFAILED;
6930    }
6931
6932    for(idx = 0; idx < elementCnt; idx++)
6933    {
6934       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6935       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6936       {
6937          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6938          return RFAILED;
6939       }
6940    }
6941
6942    idx = 0;
6943    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6944    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6945    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6946    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6947    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6948
6949    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6950    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6951    {
6952       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6953       return RFAILED;
6954    }
6955    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6956
6957    featureSets->featureSetsUplink = NULLP;
6958    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6959    if(!featureSets->featureSetsUplinkPerCC)
6960    {
6961       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6962       return RFAILED;
6963    }
6964
6965    elementCnt = 1;
6966    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6967    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6968    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6969    if(!featureSets->featureSetsUplinkPerCC->list.array)
6970    {
6971       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6972       return RFAILED;
6973    }
6974
6975    for(idx = 0; idx < elementCnt; idx++)
6976    {
6977       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6978       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6979       {
6980          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6981          return RFAILED;
6982       }
6983    }
6984
6985    idx = 0;
6986    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6987    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6988    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6989    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6990    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6991    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6992
6993    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6994    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6995    {
6996       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6997       return RFAILED;
6998    }
6999    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
7000
7001    return ROK;
7002 }
7003
7004 /*******************************************************************
7005  *
7006  * @brief Fill UE capability RAT container
7007  *
7008  * @details
7009  *
7010  *    Function : fillUeCapRatCont
7011  *
7012  *    Functionality: Fill UE capability RAT container
7013  *
7014  * @params[in] UE Capability RAT container buffer
7015  * @return ROK     - success
7016  *         RFAILED - failure
7017  *
7018  * ****************************************************************/
7019 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
7020 {
7021    uint8_t             ret = ROK;
7022    uint8_t             idx, elementCnt;
7023    asn_enc_rval_t      encRetVal;
7024    UE_NR_Capability_t  ueNrCap;
7025
7026    while(true)
7027    {
7028       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
7029
7030       /* Filling PDCP parameters */
7031       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
7032       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
7033       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
7034       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
7035       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
7036       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
7037       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
7038       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
7039       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
7040       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
7041       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
7042       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
7043       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
7044       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
7045       ueNrCap.pdcp_Parameters.shortSN = NULLP;
7046       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
7047       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
7048
7049       ueNrCap.rlc_Parameters = NULLP;
7050       ueNrCap.mac_Parameters = NULLP;
7051
7052       /* Filling PHY parameters */
7053       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
7054       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
7055       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
7056       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
7057       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
7058
7059       /* Filling RF parameters */
7060       elementCnt = 1;
7061       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
7062       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
7063       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
7064       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
7065       {
7066          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
7067          ret = RFAILED;
7068          break;
7069       }
7070
7071       for(idx = 0; idx < elementCnt; idx++)
7072       {
7073          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
7074          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
7075          {
7076             ret = RFAILED;
7077             break;
7078          }
7079       }
7080       if(ret == RFAILED)
7081          break;
7082
7083       idx = 0;
7084       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
7085       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
7086       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
7087
7088       ueNrCap.measAndMobParameters = NULLP;
7089       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
7090       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
7091       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
7092       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
7093       ueNrCap.featureSets = NULLP;
7094
7095       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
7096       if(!ueNrCap.featureSets)
7097       {
7098          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
7099          ret = RFAILED;
7100          break;
7101       }
7102
7103       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
7104       {
7105          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
7106          ret = RFAILED;
7107          break;
7108       }
7109
7110       ueNrCap.featureSetCombinations = NULLP;
7111       ueNrCap.lateNonCriticalExtension = NULLP;
7112       ueNrCap.nonCriticalExtension = NULLP;
7113
7114       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7115       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
7116       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7117       encBufSize = 0;
7118       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
7119
7120       /* Encode results */
7121       if(encRetVal.encoded == ENCODE_FAIL)
7122       {
7123          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7124             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7125          break;
7126       }
7127       else
7128       {
7129          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7130          for(int i=0; i< encBufSize; i++)
7131          {
7132             DU_LOG("%x",encBuf[i]);
7133          }
7134       }
7135
7136       ueCapRatContBuf->size = encBufSize;
7137       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
7138       if(!ueCapRatContBuf->buf)
7139       {
7140          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7141          break;
7142       }
7143       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
7144       ret = ROK;
7145       break;
7146    }
7147    freeUeCapRatCont(&ueNrCap);
7148    return ROK;
7149 }
7150
7151 /*******************************************************************
7152  *
7153  * @brief Fill UE Capability RAT container list
7154  *
7155  * @details
7156  *
7157  *    Function : fillUeCapRatContList
7158  *
7159  *    Functionality: Fill UE Capability RAT container list
7160
7161  *
7162  * @params[in] UE capability RAT container list
7163  * @return ROK     - success
7164  *         RFAILED - failure
7165  *
7166  * ****************************************************************/
7167 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
7168 {
7169     uint8_t          ret = RFAILED;
7170     uint8_t          idx, elementCnt;
7171
7172     while(true)
7173     {
7174        elementCnt = 1;
7175        ueCapablityList->list.count = elementCnt;
7176        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
7177
7178        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
7179        if(!ueCapablityList->list.array)
7180        {
7181           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7182           ret = RFAILED;
7183           break;
7184        }
7185
7186        for(idx=0; idx<elementCnt; idx++)
7187        {
7188           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
7189           if(ueCapablityList->list.array[idx] == NULLP)
7190           {
7191              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
7192              ret = RFAILED;
7193              break;
7194           }
7195        }
7196        idx = 0;
7197        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
7198        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
7199        {
7200           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
7201           ret = RFAILED;
7202           break;
7203        }
7204
7205        ret = ROK;
7206        break;
7207     }
7208     return ret;
7209 }
7210
7211 /*******************************************************************
7212  *
7213  * @brief Fill UE Capability RAT container list octet string
7214  *
7215  * @details
7216  *
7217  *    Function : fillUeCapRatContListBuf
7218  *
7219  *    Functionality: Fill UE Capability RAT container list octet string
7220
7221  *
7222  * @params[in] UE capability RAT container list buffer
7223  * @return ROK     - success
7224  *         RFAILED - failure
7225  *
7226  * ****************************************************************/
7227 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
7228 {
7229    uint8_t          ret = RFAILED;
7230    asn_enc_rval_t   encRetVal;
7231    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7232
7233    while(true)
7234    {
7235       ret = fillUeCapRatContList(&ueCapablityList);
7236       if(ret != ROK)
7237       {
7238          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7239          break;
7240       }
7241
7242       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7243       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7244       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7245       encBufSize = 0;
7246       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7247             &ueCapablityList, PrepFinalEncBuf, encBuf);
7248
7249       /* Encode results */
7250       if(encRetVal.encoded == ENCODE_FAIL)
7251       {
7252          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7253                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7254          break;
7255       }
7256       else
7257       {
7258          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7259          for(int i=0; i< encBufSize; i++)
7260          {
7261             DU_LOG("%x",encBuf[i]);
7262          }
7263       }
7264
7265       ueCapablityListBuf->size = encBufSize;
7266       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7267       if(!ueCapablityListBuf->buf)
7268       {
7269          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7270          break;
7271       }
7272       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7273       ret = ROK;
7274       break;
7275    }
7276    freeUeCapRatContList(&ueCapablityList);
7277    return ret;
7278 }
7279
7280 /*******************************************************************
7281  *
7282  * @brief Free Measurement Timing Configuration
7283  *
7284  * @details
7285  *
7286  *    Function : freeMeasuementTimingConfig
7287  *
7288  *    Functionality: Free Measurement Timing Configuration
7289  *
7290  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7291  * @return void
7292  *
7293  * ****************************************************************/
7294 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7295 {
7296    uint8_t measCfgIdx;
7297    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7298    MeasTiming_t *measTiming = NULLP;
7299
7300    if(measTimingConfig.criticalExtensions.choice.c1)
7301    {
7302       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7303       {
7304          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7305          if(measTimingCfg->measTiming)
7306          {
7307             if(measTimingCfg->measTiming->list.array)
7308             {
7309                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7310                {
7311                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7312                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7313                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7314                }
7315                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7316             }
7317             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7318          }
7319          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7320       }
7321       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7322    }
7323 }
7324
7325 /*******************************************************************
7326  *
7327  * @brief Fill Measurement Timing Configuration
7328  *
7329  * @details
7330  *
7331  *    Function : fillMeasTimingCfg
7332  *
7333  *    Functionality: Fill Measurement Timing Configuration
7334  *
7335  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7336  * @return ROK     - success
7337  *         RFAILED - failure
7338  *
7339  * ****************************************************************/
7340 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7341 {
7342    uint8_t elementCnt = 0;
7343    uint8_t measCfgIdx = 0;
7344    MeasTiming_t *measTiming;
7345    SSB_MTC_t *smtc;
7346
7347    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7348    if(!measTimingCfg->measTiming)
7349    {
7350       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7351       return RFAILED;
7352    }
7353
7354    elementCnt = 1;
7355    measTimingCfg->measTiming->list.count = elementCnt;
7356    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7357    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7358    if(!measTimingCfg->measTiming->list.array)
7359    {
7360       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7361       return RFAILED;
7362    }
7363
7364    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7365    {
7366       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7367       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7368       {
7369          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7370          return RFAILED;
7371       }
7372    }
7373
7374    measCfgIdx = 0;
7375    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7376    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7377    if(!measTiming->frequencyAndTiming)
7378    {
7379       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7380       return RFAILED;
7381    }
7382
7383    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7384    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7385
7386    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7387    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7388    smtc->periodicityAndOffset.choice.sf20 = 0;
7389    smtc->duration = SSB_MTC__duration_sf1;
7390    return ROK;
7391 }
7392
7393 /*******************************************************************
7394  *
7395  * @brief Fill Measurement Timing Configuration Octet string
7396  *
7397  * @details
7398  *
7399  *    Function : fillMeasConfigBuf
7400  *
7401  *    Functionality: Fill Measurement Timing Configuration Octet string
7402
7403  *
7404  * @params[in] MeasConfig_t *measConfgBuf
7405  * @return ROK     - success
7406  *         RFAILED - failure
7407  *
7408  * ****************************************************************/
7409 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7410 {
7411    uint8_t          ret = RFAILED;
7412    asn_enc_rval_t   encRetVal;
7413    MeasurementTimingConfigurationRrc_t measTimingConfig;
7414
7415    while(true)
7416    {
7417       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7418       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7419       if(!measTimingConfig.criticalExtensions.choice.c1)
7420       {
7421          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7422          return RFAILED;
7423       }
7424       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7425
7426       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7427       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7428       {
7429          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7430          return RFAILED;
7431       }
7432
7433       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7434       if(ret != ROK)
7435       {
7436          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7437          break;
7438       }
7439
7440       /* Encode measurement timing configuration into octet string */
7441       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7442       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7443       encBufSize = 0;
7444       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7445
7446       /* Encode results */
7447       if(encRetVal.encoded == ENCODE_FAIL)
7448       {
7449          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7450                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7451          break;
7452       }
7453       else
7454       {
7455          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7456          for(int i=0; i< encBufSize; i++)
7457          {
7458             DU_LOG("%x",encBuf[i]);
7459          }
7460       }
7461
7462       measTimingConfigBuf->size = encBufSize;
7463       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7464       if(!measTimingConfigBuf->buf)
7465       {
7466          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7467          break;
7468       }
7469       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7470       ret = ROK;
7471       break;
7472    }
7473    freeMeasuementTimingConfig(measTimingConfig);
7474    return ret;
7475 }
7476
7477 /******************************************************************
7478  *
7479  * @brief Free RRC reconfiguration non-critical extension
7480  *
7481  * @details
7482  *
7483  *    Function : freeRrcReconfigNonCriticalExt
7484  *
7485  *    Functionality: Free RRC reconfiguration non-critical extension
7486  *
7487  * @params[in] RRC reconfiguration IE
7488  * @return void
7489  *
7490  * ****************************************************************/
7491 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7492 {
7493    if(rrcRecfg->masterCellGroup)
7494    {
7495       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7496    }
7497 }
7498
7499 /******************************************************************
7500  *
7501  * @brief Free measurement object addmod list
7502  *
7503  * @details
7504  *
7505  *    Function : freeMeasObjToAddModList
7506  *
7507  *    Functionality: Free measurement object add mod list
7508  *
7509  * @params[in] Measurement object add/mod list
7510  * @return void
7511  *
7512  * ****************************************************************/
7513 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7514 {
7515    uint8_t objIdx;
7516    MeasObjectNR_t *measObject;
7517
7518    if(measObjList->list.array)
7519    {
7520       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7521       {
7522          if(measObjList->list.array[objIdx])
7523          {
7524             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7525             {
7526                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7527                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7528                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7529                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7530                if(measObject->absThreshSS_BlocksConsolidation)
7531                {
7532                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7533                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7534                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7535                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7536                }
7537                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7538                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7539                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7540                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7541                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7542             }
7543             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7544          }
7545       }
7546       CU_FREE(measObjList->list.array, measObjList->list.size);
7547    }
7548 }
7549
7550 /******************************************************************
7551  *
7552  * @brief Free report config add mod list
7553  *
7554  * @details
7555  *
7556  *    Function : freeReportCfgToAddModList
7557  *
7558  *    Functionality: Free report config add mod list
7559  *
7560  * @params[in] Report config list
7561  * @return void
7562  *
7563  * ****************************************************************/
7564 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7565 {
7566    uint8_t reportCfgIdx;
7567    ReportConfigToAddMod_t *reportCfg;
7568    ReportConfigNR_t *reportCfgNr;
7569    EventTriggerConfig_t *eventTriggCfg;
7570
7571    if(reportCfgList->list.array)
7572    {
7573       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7574       {
7575          if(reportCfgList->list.array[reportCfgIdx])
7576          {
7577             reportCfg = reportCfgList->list.array[reportCfgIdx];
7578             if(reportCfg->reportConfig.choice.reportConfigNR)
7579             {
7580                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7581                if(reportCfgNr->reportType.choice.eventTriggered)
7582                {
7583                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7584                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7585                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7586                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7587                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7588                }
7589             }
7590          }
7591          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7592       }
7593       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7594    }
7595 }
7596
7597 /******************************************************************
7598  *
7599  * @brief Free measurement id to add mod list
7600  *
7601  * @details
7602  *
7603  *    Function : freeMeasIdToAddModList
7604  *
7605  *    Functionality: Free measurement id to add mod list
7606  *
7607  * @params[in] Measurement id to add mod list
7608  * @return void
7609  *
7610  * ****************************************************************/
7611 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7612 {
7613    uint8_t measIdIdx;
7614    if(measIdList->list.array)
7615    {
7616       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7617       {
7618          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7619       }
7620       CU_FREE(measIdList->list.array, measIdList->list.size);
7621    }
7622 }
7623
7624 /*******************************************************************
7625  *
7626  * @brief Free quantity config
7627  *
7628  * @details
7629  *
7630  *    Function : freeQunatityConfig
7631  *
7632  *    Functionality: Free quantity config
7633  *
7634  * @params[in] Quantity Config
7635  * @return void
7636  *
7637  * ****************************************************************/
7638 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7639 {
7640    uint8_t quanCfgIdx;
7641    QuantityConfigNR_t *quantityCfgNr;
7642
7643    if(quantityCfg->quantityConfigNR_List)
7644    {
7645       if(quantityCfg->quantityConfigNR_List->list.array)
7646       {
7647          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7648          {
7649             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7650             {
7651                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7652                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7653                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7654                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7655                if(quantityCfgNr->quantityConfigRS_Index)
7656                {
7657                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7658                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7659                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7660                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7661                }
7662                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7663             }
7664          }
7665          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7666       }
7667       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7668    }
7669 }
7670
7671 /******************************************************************
7672  *
7673  * @brief Free measurement Config
7674  *
7675  * @details
7676  *
7677  *    Function : freeMeasConfig
7678  *
7679  *    Functionality: Free measurement config
7680  *
7681  * @params[in] Measurement config
7682  * @return void
7683  *
7684  * ****************************************************************/
7685 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7686 {
7687    if(measConfig->measObjectToAddModList)
7688    {
7689       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7690       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7691    }
7692    if(measConfig->reportConfigToAddModList)
7693    {
7694       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7695       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7696    }
7697    if(measConfig->measIdToAddModList)
7698    {
7699       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7700       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7701    }
7702    if(measConfig->s_MeasureConfig)
7703    {
7704       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7705    }
7706    if(measConfig->quantityConfig)
7707    {
7708       freeQuantityConfig(measConfig->quantityConfig);
7709       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7710    }
7711 }
7712 /******************************************************************
7713  *
7714  * @brief Free DRB to AddMod List
7715  *
7716  * @details
7717  *
7718  *    Function : freeDrbToAddModList
7719  *
7720  *    Functionality: Free SRB to AddMod List
7721  *
7722  * @params[in] SBR to add/mod list
7723  * @return void
7724  *
7725  * ****************************************************************/
7726 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7727 {
7728    uint8_t drbIdx;
7729    if(drbToAddList->list.array)
7730    {
7731       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7732       {
7733          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7734          {
7735             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7736             {
7737                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7738                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7739                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7740                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7741             }
7742             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7743             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7744          }
7745          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7746       }
7747       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7748    }
7749 }
7750
7751 /******************************************************************
7752  *
7753  * @brief Free SRB to AddMod List
7754  *
7755  * @details
7756  *
7757  *    Function : freeSrbToAddModList
7758  *
7759  *    Functionality: Free SRB to AddMod List
7760  *
7761  * @params[in] SBR to add/mod list
7762  * @return void
7763  *
7764  * ****************************************************************/
7765 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7766 {
7767    uint8_t srbIdx;
7768    if(srbToAddList->list.array)
7769    {
7770       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7771       {
7772          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7773          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7774          {
7775             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7776             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7777          }
7778
7779          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7780       }
7781       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7782    }
7783 }
7784
7785 /******************************************************************
7786  *
7787  * @brief Free Radio Bearer Config
7788  *
7789  * @details
7790  *
7791  *    Function : freeRadioBearerConfig
7792  *
7793  *    Functionality: Free Radio Bearer config
7794  *
7795  * @params[in] Radio bearer config
7796  * @return void
7797  *
7798  * ****************************************************************/
7799 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7800 {
7801    if(radioBearerConfig->srb_ToAddModList)
7802    {
7803       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7804       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7805    }
7806    if(radioBearerConfig->drb_ToAddModList)
7807    {
7808       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7809       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7810    }
7811 }
7812
7813 /******************************************************************
7814  *
7815  * @brief Free reconfiguration message
7816  *
7817  * @details
7818  *
7819  *    Function : freeRrcReconfig
7820  *
7821  *    Functionality: Free reconfiguration message
7822  *
7823  * @params[in] RRC Reconfiguration message
7824  * @return void
7825  *
7826  * ****************************************************************/
7827 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7828 {
7829    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7830    {
7831       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7832       {
7833          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7834          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7835       }
7836       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7837       {
7838          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7839          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7840       }
7841       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7842       {
7843          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7844          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7845       }
7846       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7847    }
7848 }
7849
7850 /******************************************************************
7851  *
7852  * @brief Fill SRB To Add Mod list
7853  *
7854  * @details
7855  *
7856  *    Function : fillSrbToAddModList
7857  *
7858  *    Functionality: fill SRB to Add Mod list
7859  *
7860  * @params[in] UE control block
7861  *             SRB to Add/Mod list
7862  * @return ROK     - success
7863  *         RFAILED - failure
7864  *
7865  * ****************************************************************/
7866 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7867 {
7868    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7869
7870    if(updateAllRbCfg)
7871       elementCnt = ueCb->numSrb;
7872    else
7873    {
7874       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7875       {
7876          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7877             elementCnt++;
7878       }
7879    }
7880
7881    if(!elementCnt)
7882    {
7883       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7884       return ROK;
7885    }
7886
7887    srbToAddList->list.count = elementCnt;
7888    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7889
7890    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7891    if(!srbToAddList->list.array)
7892    {
7893       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7894       return RFAILED;
7895    }
7896
7897    srbIdx = 0;
7898    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7899    {
7900       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7901          continue;
7902
7903       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7904       if(!srbToAddList->list.array[srbIdx])
7905       {
7906          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7907          return RFAILED;
7908       }
7909
7910       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7911
7912       /* Reestablish PDCP */
7913       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7914       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7915       {
7916          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7917          return RFAILED;
7918       }
7919       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7920
7921       /* PDCP configuration */
7922       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7923       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7924       {
7925          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7926          return RFAILED;
7927       }
7928
7929       /* Reordering timer */
7930       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7931       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7932       {
7933          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7934          return RFAILED;
7935       }
7936       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7937
7938       srbIdx++;
7939    }
7940    return ROK;
7941 }
7942
7943 /******************************************************************
7944  *
7945  * @biief Fill DRBeTo Add Mod list
7946  *
7947  * @details
7948  *
7949  *    Function : fillDrbToAddModList
7950  *
7951  *    Functionality: fill DRB to Add Mod list
7952  *
7953  * @params[in] UE control block
7954  *             DRB to Add/Mod list
7955  * @return ROK     - success
7956  *         RFAILED - failure
7957  *
7958  * ****************************************************************/
7959 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7960 {
7961    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7962
7963    if(updateAllRbCfg)
7964       elementCnt = ueCb->numDrb;
7965    else
7966    {
7967       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7968       {
7969          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7970             elementCnt++;
7971       }
7972    }
7973
7974    if(!elementCnt)
7975    {
7976       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7977       return ROK;
7978    }
7979
7980
7981    drbToAddList->list.count = elementCnt;
7982    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7983
7984    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7985    if(!drbToAddList->list.array)
7986    {
7987       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7988       return RFAILED;
7989    }
7990
7991    drbIdx = 0;
7992    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7993    {
7994       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7995          continue;
7996
7997       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7998       if(!drbToAddList->list.array[drbIdx])
7999       {
8000          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
8001          return RFAILED;
8002       }
8003
8004       /* DRB Id */
8005       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
8006
8007       /* PDCP Config */
8008       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
8009       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
8010       {
8011          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
8012          return RFAILED;
8013       }
8014
8015       /* PDCP Config -> DRB */
8016       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
8017       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
8018       {
8019          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
8020          return RFAILED;
8021       }
8022
8023       /* DRB -> Discard Timer */
8024       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
8025       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
8026       {
8027          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
8028          return RFAILED;
8029       }
8030       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
8031
8032       /* UL PDCP SN length */
8033       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
8034       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
8035       {
8036          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
8037          return RFAILED;
8038       }
8039       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
8040
8041       /* DL PDCP SN length */
8042       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
8043       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
8044       {
8045          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
8046          return RFAILED;
8047       }
8048       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
8049
8050       /* Header Compression */
8051       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
8052        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
8053
8054       /* Reordering timer */
8055       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
8056       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
8057       {
8058          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
8059          return RFAILED;
8060       }
8061       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
8062
8063       drbIdx++;
8064    }
8065
8066    return ROK;
8067 }
8068
8069 /******************************************************************
8070  *
8071  * @brief Fill Radio bearer configuration
8072  *
8073  * @details
8074  *
8075  *    Function : fillRadioBearerConfig
8076  *
8077  *    Functionality: Fill Radio bearer configuration
8078  *
8079  * @params[in] UE control block
8080  *             Radio bearer config pointer
8081  * @return ROK     - success
8082  *         RFAILED - failure
8083  *
8084  * ****************************************************************/
8085 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
8086 {
8087    /* SRB To Add/Mod List */
8088    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
8089    if(!radioBearerConfig->srb_ToAddModList)
8090    {
8091       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
8092       return RFAILED;
8093    }
8094    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
8095    {
8096       DU_LOG("\nERROR  -->  F1AP: failed to fill SRB to AddMod List");
8097       return RFAILED;
8098    }
8099
8100    /* DRB To Add/Mod List */
8101    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
8102    if(!radioBearerConfig->drb_ToAddModList)
8103    {
8104       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
8105       return RFAILED;
8106     }
8107    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
8108    {
8109       DU_LOG("\nERROR  -->  F1AP: failed to fill DRB to AddMod List ");
8110       return RFAILED;
8111    }
8112
8113    return ROK;
8114 }
8115
8116 /*******************************************************************
8117  *
8118  * @brief Fill measurement object to add/mod list
8119  *
8120  * @details
8121  *
8122  *    Function : fillMeasObjToAddModList
8123  *
8124  *    Functionality: Fill measurement object to add/mod list
8125  *
8126  * @params[in] Measurement object to add/mod list
8127  * @return ROK     - success
8128  *         RFAILED - failure
8129  *
8130  * ****************************************************************/
8131 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
8132 {
8133    uint8_t elementCnt, objIdx;
8134    MeasObjectNR_t *measObject;
8135
8136    elementCnt = 1;
8137    measObjList->list.count = elementCnt;
8138    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
8139
8140    CU_ALLOC(measObjList->list.array, measObjList->list.size);
8141    if(!measObjList->list.array)
8142    {
8143       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
8144       return RFAILED;
8145    }
8146
8147    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
8148    {
8149       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
8150       if(!measObjList->list.array[objIdx])
8151       {
8152          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
8153          return RFAILED;
8154       }
8155    }
8156
8157    objIdx = 0;
8158    measObjList->list.array[objIdx]->measObjectId = 1;
8159    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
8160    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
8161    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
8162    {
8163       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
8164       return RFAILED;
8165    }
8166
8167    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
8168
8169    /* SSB frequency */
8170    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
8171    if(!measObject->ssbFrequency)
8172    {
8173       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
8174       return RFAILED;
8175    }
8176    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
8177
8178    /* Subcarrier spacing */
8179    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8180    if(!measObject->ssbSubcarrierSpacing)
8181    {
8182       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
8183       return RFAILED;
8184    }
8185    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
8186
8187    /* SMTC1 */
8188    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
8189    if(!measObject->smtc1)
8190    {
8191       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
8192       return RFAILED;
8193    }
8194    measObject->smtc1->duration = SSB_MTC__duration_sf1;
8195    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
8196    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
8197
8198    /* Absoulute threshold SSB consolidation */
8199    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
8200    if(!measObject->absThreshSS_BlocksConsolidation)
8201    {
8202       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
8203       return RFAILED;
8204    }
8205
8206    /* RSRP threshold */
8207    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
8208    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
8209    {
8210       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
8211       return RFAILED;
8212    }
8213    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
8214
8215    /* RSRQ threshold */
8216    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
8217    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
8218    {
8219       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
8220       return RFAILED;
8221    }
8222    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
8223
8224    /* SINR threshold */
8225    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
8226    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
8227    {
8228       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
8229       return RFAILED;
8230    }
8231    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8232
8233    /* Number of SSBs to average */
8234    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8235    if(!measObject->nrofSS_BlocksToAverage)
8236    {
8237       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8238       return RFAILED;
8239    }
8240    *(measObject->nrofSS_BlocksToAverage) = 2;
8241
8242    /* Quantity Config index */
8243    measObject->quantityConfigIndex = 1;
8244
8245    /* Offset MO */
8246    /* RSRP offset for SSB */
8247    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8248    if(!measObject->offsetMO.rsrpOffsetSSB)
8249    {
8250       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8251       return RFAILED;
8252    }
8253    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8254
8255    /* RSRQ offset for SSB */
8256    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8257    if(!measObject->offsetMO.rsrpOffsetSSB)
8258    {
8259       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8260       return RFAILED;
8261    }
8262    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8263
8264    /* SINR offset for SSB */
8265    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8266    if(!measObject->offsetMO.sinrOffsetSSB)
8267    {
8268       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8269       return RFAILED;
8270    }
8271    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8272
8273    return ROK;
8274 }
8275
8276 /*******************************************************************
8277  *
8278  * @brief Fill Report configuration to Add/mod list
8279  *
8280  * @details
8281  *
8282  *    Function : fillReportCfgToAddModList
8283  *
8284  *    Functionality: Fill Report configuration to Add/mod list
8285  *
8286  * @params[in] Report Config To Add/Mod List
8287  * @return ROK     - success
8288  *         RFAILED - failure
8289  *
8290  * ****************************************************************/
8291 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8292 {
8293    uint8_t elementCnt;
8294    uint8_t reportCfgIdx;
8295    ReportConfigToAddMod_t *reportCfg;
8296    ReportConfigNR_t *reportCfgNr;
8297    EventTriggerConfig_t *eventTriggCfg;
8298
8299    elementCnt = 1;
8300    reportCfgList->list.count = elementCnt;
8301    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8302
8303    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8304    if(!reportCfgList->list.array)
8305    {
8306       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8307       return RFAILED;
8308    }
8309
8310    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8311    {
8312       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8313       if(!reportCfgList->list.array[reportCfgIdx])
8314       {
8315          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8316          return RFAILED;
8317       }
8318    }
8319
8320    reportCfgIdx = 0;
8321    reportCfg = reportCfgList->list.array[reportCfgIdx];
8322    reportCfg->reportConfigId = 1;
8323    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8324
8325    /* Report Configuration for NR */
8326    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8327    if(!reportCfg->reportConfig.choice.reportConfigNR)
8328    {
8329       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8330       return RFAILED;
8331    }
8332    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8333
8334    /* Report Type */
8335    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8336    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8337    if(!reportCfgNr->reportType.choice.eventTriggered)
8338    {
8339       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8340       return RFAILED;
8341    }
8342    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8343
8344    /* Event 3 */
8345    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8346    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8347    if(!eventTriggCfg->eventId.choice.eventA3)
8348    {
8349       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8350       return RFAILED;
8351    }
8352
8353    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8354    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8355    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8356    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8357    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8358    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8359
8360    /* Reference Signal Type */
8361    eventTriggCfg->rsType = NR_RS_Type_ssb;
8362
8363    /* Report Interval */
8364    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8365
8366    /* Report Amount */
8367    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8368
8369    /* Report Quantity cell */
8370    eventTriggCfg->reportQuantityCell.rsrp = true;
8371    eventTriggCfg->reportQuantityCell.rsrq = false;
8372    eventTriggCfg->reportQuantityCell.sinr = false;
8373
8374    /* Maximum reported cells */
8375    eventTriggCfg->maxReportCells = 3;
8376
8377    /* Report qunatity RS Indexes */
8378    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8379    if(!eventTriggCfg->reportQuantityRS_Indexes)
8380    {
8381       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8382       return RFAILED;
8383    }
8384    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8385    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8386    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8387
8388    /* Maximum number of RS indexes to report */
8389    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8390    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8391    {
8392       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8393       return RFAILED;
8394    }
8395    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8396
8397    /* Include Beam measurement */
8398    eventTriggCfg->includeBeamMeasurements = false;
8399
8400    return ROK;
8401 }
8402
8403 /*******************************************************************
8404  *
8405  * @brief Fill measurement Id to add/mod list
8406
8407  * @details
8408  *
8409  *    Function : fillMeasIdToAddModList
8410  *
8411  *    Functionality: Fill measurement Id to add/mod list
8412  *
8413  * @params[in] Measurement Id to add/mod list
8414  * @return ROK     - success
8415  *         RFAILED - failure
8416  *
8417  * ****************************************************************/
8418 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8419 {
8420    uint8_t elementCnt;
8421    uint8_t measIdIdx;
8422
8423    elementCnt = 1;
8424    measIdList->list.count = elementCnt;
8425    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8426
8427    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8428    if(!measIdList->list.array)
8429    {
8430       return RFAILED;
8431    }
8432
8433    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8434    {
8435       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8436       if(!measIdList->list.array[measIdIdx])
8437       {
8438          return RFAILED;
8439       }
8440
8441       measIdIdx=0;
8442       measIdList->list.array[measIdIdx]->measId = 1;
8443       measIdList->list.array[measIdIdx]->measObjectId = 1;
8444       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8445    }
8446    return ROK;
8447 }
8448
8449 /*******************************************************************
8450  *
8451  * @brief Fill s-measurement configuration
8452  *
8453  * @details
8454  *
8455  *    Function : fillSMeasConfig
8456  *
8457  *    Functionality: Fill s-measurement configuration
8458  *
8459  * @params[in] s-Measurement config
8460  * @return ROK     - success
8461  *         RFAILED - failure
8462  *
8463  * ****************************************************************/
8464 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8465 {
8466    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8467    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8468
8469    return ROK;
8470 }
8471
8472 /*******************************************************************
8473  *
8474  * @brief Fill quantity config
8475  *
8476  * @details
8477  *
8478  *    Function : fillQunatityConfig
8479  *
8480  *    Functionality: Fill quantity config
8481  *
8482  * @params[in] Quantity Config
8483  * @return ROK     - success
8484  *         RFAILED - failure
8485  *
8486  * ****************************************************************/
8487 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8488 {
8489    uint8_t elementCnt = 0;
8490    uint8_t quanCfgIdx = 0;
8491    QuantityConfigNR_t *quantityCfgNr;
8492
8493    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8494    if(!quantityCfg->quantityConfigNR_List)
8495    {
8496       return RFAILED;
8497    }
8498
8499    elementCnt = 1;
8500    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8501    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8502
8503    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8504    if(!quantityCfg->quantityConfigNR_List->list.array)
8505    {
8506       return RFAILED;
8507    }
8508
8509    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8510    {
8511       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8512       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8513       {
8514          return RFAILED;
8515       }
8516    }
8517
8518    quanCfgIdx = 0;
8519    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8520
8521    /* Quantity Config of Reference signal */
8522    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8523    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8524    {
8525       return RFAILED;
8526    }
8527    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8528
8529    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8530    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8531    {
8532       return RFAILED;
8533    }
8534    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8535
8536    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8537    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8538    {
8539       return RFAILED;
8540    }
8541    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8542
8543    /* Quantity Config RS index */
8544    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8545    if(!quantityCfgNr->quantityConfigRS_Index)
8546    {
8547       return RFAILED;
8548    }
8549
8550    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8551    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8552    {
8553       return RFAILED;
8554    }
8555    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8556
8557    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8558    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8559    {
8560       return RFAILED;
8561    }
8562    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8563
8564    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8565    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8566    {
8567       return RFAILED;
8568    }
8569    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8570
8571    return ROK;
8572 }
8573
8574 /*******************************************************************
8575  *
8576  * @brief Fill measurement configuration
8577  *
8578  * @details
8579  *
8580  *    Function : fillMeasConfig
8581  *
8582  *    Functionality: Fill measurement configuration
8583  *
8584  * @params[in] Measurement config
8585  * @return ROK     - success
8586  *         RFAILED - failure
8587  *
8588  * ****************************************************************/
8589 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8590 {
8591    /* Measurement object to add/mod list */
8592    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8593    if(!measConfig->measObjectToAddModList)
8594    {
8595       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8596       return RFAILED;
8597    }
8598    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8599    {
8600       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8601       return RFAILED;
8602    }
8603
8604    /* Report Config To add/mod list */
8605    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8606    if(!measConfig->reportConfigToAddModList)
8607    {
8608       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8609       return RFAILED;
8610    }
8611    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8612    {
8613       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8614       return RFAILED;
8615    }
8616
8617    /* Measurement Id to add/mod list */
8618    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8619    if(!measConfig->measIdToAddModList)
8620    {
8621       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8622       return RFAILED;
8623    }
8624    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8625    {
8626       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8627       return RFAILED;
8628    }
8629
8630    /* S-Measurement config */
8631    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8632    if(!measConfig->s_MeasureConfig)
8633    {
8634       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8635       return RFAILED;
8636    }
8637    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8638    {
8639       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8640       return RFAILED;
8641    }
8642
8643    /* Qunatity Config */
8644    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8645    if(!measConfig->quantityConfig)
8646    {
8647       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8648       return RFAILED;
8649    }
8650    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8651    {
8652       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8653       return RFAILED;
8654    }
8655
8656 return ROK;
8657 }
8658
8659 /*******************************************************************
8660  *
8661  * @brief Fill RRC reconfiguration non-critical extension IE
8662  *
8663  * @details
8664  *
8665  *    Function : fillRrcReconfigNonCriticalExt
8666  *
8667  *    Functionality: Fill RRC reconfiguration non-critical extension
8668  *
8669  * @params[in] RRC Reconfig Non-critical extension
8670  * @return ROK     - success
8671  *         RFAILED - failure
8672  *
8673  * ****************************************************************/
8674 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8675 {
8676    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8677    if(!rrcRecfg->masterCellGroup)
8678    {
8679       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8680       return RFAILED;
8681    }
8682
8683    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8684    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8685    if(!rrcRecfg->masterCellGroup->buf)
8686    {
8687       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8688       return RFAILED;
8689    }
8690    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8691
8692 #if 0
8693    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8694     * received from DU */
8695    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8696    {
8697       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8698       return RFAILED;
8699    }
8700 #endif
8701
8702    return ROK;
8703 }
8704
8705 /*******************************************************************
8706  *
8707  * @brief Fill RRC reconfiguration structure
8708  *
8709  * @details
8710  *
8711  *    Function : fillRrcReconfig
8712  *
8713  *    Functionality: Fill RRC reconfiguration
8714
8715  *
8716  * @params[in] UE Cb
8717  *             RRC reconfiguration structure
8718  * @return ROK     - success
8719  *         RFAILED - failure
8720  *
8721  * ****************************************************************/
8722 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8723 {
8724    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8725
8726    rrcReconfig->rrc_TransactionIdentifier = 1;
8727    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8728
8729    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8730    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8731    {
8732       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8733       return RFAILED;
8734    }
8735
8736    /* Radio Bearer Configuration */
8737    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8738    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8739    {
8740       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8741       return RFAILED;
8742    }
8743    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8744    {
8745       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8746       return RFAILED;
8747    }
8748
8749    /* Measurement Configuration */
8750    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8751    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8752    {
8753       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8754       return RFAILED;
8755    }
8756    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8757    {
8758       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8759       return RFAILED;
8760    }
8761
8762    /* Non Critical extension */
8763    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8764    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8765    {
8766       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8767       return RFAILED;
8768    }
8769    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8770    {
8771       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8772       return RFAILED;
8773    }
8774    return ROK;
8775 }
8776
8777 /*******************************************************************
8778  *
8779  * @brief Fill RRC reconfiguration Octet string
8780  *
8781  * @details
8782  *
8783  *    Function : fillRrcReconfigBuf
8784  *
8785  *    Functionality: Fill RRC reconfiguration octet string
8786
8787  *
8788  * @params[in] OCTET_STRING_t buffer
8789  * @return ROK     - success
8790  *         RFAILED - failure
8791  *
8792  * ****************************************************************/
8793 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8794 {
8795    uint8_t          ret = RFAILED;
8796    asn_enc_rval_t   encRetVal;
8797    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8798    rrcReconfig = &rrcRecfg;
8799
8800    while(true)
8801    {
8802       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8803       {
8804          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8805          break;
8806       }
8807
8808       /* Encode RRC Reconfiguration */
8809       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8810       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8811       encBufSize = 0;
8812       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8813
8814       /* Encode results */
8815       if(encRetVal.encoded == ENCODE_FAIL)
8816       {
8817          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8818                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8819          break;
8820       }
8821       else
8822       {
8823          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8824          for(int i=0; i< encBufSize; i++)
8825          {
8826             DU_LOG("%x",encBuf[i]);
8827          }
8828       }
8829
8830       rrcReconfigBuf->size = encBufSize;
8831       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8832       if(!rrcReconfigBuf->buf)
8833       {
8834          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8835          break;
8836       }
8837       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8838       ret = ROK;
8839       break;
8840    }
8841
8842    freeRrcReconfig(rrcReconfig);
8843    return ret;
8844 }
8845
8846 /*******************************************************************
8847  *
8848  * @brief Fill HO preparation information Octet string
8849  *
8850  * @details
8851  *
8852  *    Function : fillHOPreparationInfoBuf
8853  *
8854  *    Functionality: Fill HO preparation information Octet string
8855
8856  *
8857  * @params[in] HandoverPreparationInformation_t buffer
8858  * @return ROK     - success
8859  *         RFAILED - failure
8860  *
8861  * ****************************************************************/
8862 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8863 {
8864    uint8_t          ret = RFAILED;
8865    asn_enc_rval_t   encRetVal;
8866    HandoverPreparationInformationRrc_t hoPrepInfo;
8867    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8868
8869    while(true)
8870    {
8871
8872       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8873       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8874       if(!hoPrepInfo.criticalExtensions.choice.c1)
8875       {
8876          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8877          break;
8878       }
8879       hoPrepInfo.criticalExtensions.choice.c1->present = \
8880          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8881
8882       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8883          sizeof(HandoverPreparationInformationRrc_IEs_t));
8884       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8885       {
8886          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8887          break;
8888       }
8889       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8890
8891       /* Fill UE Capability RAT container list */
8892       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8893       if(ret != ROK)
8894       {
8895          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8896          break;
8897       }
8898
8899       /* Fill Source config */
8900       hoPrepInfoIe->sourceConfig = NULLP;
8901       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8902       if(!hoPrepInfoIe->sourceConfig)
8903       {
8904          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8905          return RFAILED;
8906       }
8907       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8908
8909       if(ret != ROK)
8910       {
8911          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8912          return RFAILED;
8913       }
8914
8915       hoPrepInfoIe->rrm_Config = NULLP;
8916       hoPrepInfoIe->as_Context = NULLP;
8917       hoPrepInfoIe->nonCriticalExtension = NULLP;
8918
8919       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8920       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8921       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8922       encBufSize = 0;
8923       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8924             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8925
8926       /* Encode results */
8927       if(encRetVal.encoded == ENCODE_FAIL)
8928       {
8929          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8930                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8931          break;
8932       }
8933       else
8934       {
8935          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8936          for(int i=0; i< encBufSize; i++)
8937          {
8938             DU_LOG("%x",encBuf[i]);
8939          }
8940       }
8941
8942       hoPrepInfoBuf->size = encBufSize;
8943       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8944       if(!hoPrepInfoBuf->buf)
8945       {
8946          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8947          break;
8948       }
8949       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8950       ret = ROK;
8951       break;
8952    }
8953    freeHOPreparationInfo(&hoPrepInfo);
8954    return ret;
8955 }
8956
8957 /*******************************************************************
8958  *
8959  * @brief Fills CuToDuContainer
8960  *
8961  * @details
8962  *
8963  *    Function : fillCuToDuContainer
8964  *
8965  *    Functionality: Fills CuToDuContainer
8966  *
8967  * @params[in] pointer to CUtoDURRCInformation_t
8968  *
8969  * @return ROK     - success
8970  *         RFAILED - failure
8971  *
8972  ******************************************************************/
8973
8974 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8975 {
8976    uint8_t elementCnt = 0;
8977    uint8_t ret = ROK;
8978    uint8_t idx;
8979
8980    /* UE Capabulity RAT Container List */
8981    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8982    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8983    {
8984       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8985       return RFAILED;
8986    }
8987    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8988
8989    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8990    if(!rrcMsg->measConfig)
8991    {
8992       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8993       return RFAILED;
8994    }
8995    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8996
8997    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8998    {
8999       /* IE extensions */
9000       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9001       if(rrcMsg->iE_Extensions)
9002       {
9003          elementCnt = 1;
9004          rrcMsg->iE_Extensions->list.count = elementCnt;
9005          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
9006
9007          /* Initialize the CUtoDURRCInformation_ExtIEs */
9008          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9009
9010          if(rrcMsg->iE_Extensions->list.array == NULLP)
9011          {
9012             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
9013             ret = RFAILED;
9014          }
9015
9016          for(idx=0; idx<elementCnt; idx++)
9017          {
9018             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
9019             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
9020             {
9021                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
9022                ret = RFAILED;
9023             }
9024          }
9025
9026          idx = 0;
9027 #if 0
9028          /* Cell Group Configuration */
9029          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
9030          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9031          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
9032                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
9033          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
9034          idx++;
9035 #endif
9036          /* Handover Preparation Information */
9037          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
9038          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
9039          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
9040                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
9041          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
9042       }
9043    }
9044    return ret;
9045 }
9046 /*******************************************************************
9047  *
9048  * @brief Build the drx cycle
9049  *
9050  * @details
9051  *
9052  *    Function : BuildDrxCycle
9053  *
9054  *    Functionality: Build drx cycle IE
9055  *
9056  * @params[in] pointer to DRXCycle_t
9057  *
9058  * @return ROK     - success
9059  *         RFAILED - failure
9060  *
9061  ******************************************************************/
9062 uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
9063 {
9064    drxCycle->longDRXCycleLength = LongDRXCycleLength_ms40;
9065    CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
9066    if(!drxCycle->shortDRXCycleLength)
9067    {
9068       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleLength");
9069       return RFAILED;
9070    }
9071    *(drxCycle->shortDRXCycleLength) = ShortDRXCycleLength_ms4;
9072
9073    CU_ALLOC(drxCycle->shortDRXCycleTimer, sizeof(ShortDRXCycleTimer_t));
9074    if(!drxCycle->shortDRXCycleTimer)
9075    {
9076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for shortDRXCycleTimer");
9077       return RFAILED;
9078    }
9079    *(drxCycle->shortDRXCycleTimer) = 4;
9080    return ROK;
9081 }
9082 /*******************************************************************
9083  *
9084  * @brief Free CuToDuContainer
9085  *
9086  * @details
9087  *
9088  *    Function : FreeCuToDuInfo
9089  *
9090  *    Functionality: Free CuToDuContainer
9091  *
9092  * @params[in] pointer to CUtoDURRCInformation_t
9093  *
9094  * @return ROK     - success
9095  *         RFAILED - failure
9096  *
9097  ******************************************************************/
9098
9099 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9100 {
9101    uint8_t idx, idx2;
9102
9103    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9104    {
9105       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9106          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
9107       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
9108    }
9109    if(rrcMsg->iE_Extensions)
9110    {
9111       if(rrcMsg->iE_Extensions->list.array)
9112       {
9113          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
9114          {
9115             if(rrcMsg->iE_Extensions->list.array[idx])
9116             {
9117                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
9118                {
9119                   case ProtocolIE_ID_id_CellGroupConfig:
9120                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9121                      {
9122                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
9123                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
9124
9125                      }
9126                      break;
9127                   default:
9128                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9129                            rrcMsg->iE_Extensions->list.array[idx]->id);
9130                      break;
9131                }
9132             }
9133             break;
9134          }
9135          for(idx2 = 0; idx2 < idx; idx2++)
9136          {
9137             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
9138          }
9139          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
9140
9141       }
9142
9143       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
9144    }
9145 }
9146 /*******************************************************************
9147  *
9148  * @brief Builds and sends the UE Setup Request
9149  *
9150  * @details
9151  *
9152  *    Function : BuildAndSendUeContextSetupReq
9153  *
9154  *    Functionality: Constructs the UE Setup Request and sends
9155  *                   it to the CU through SCTP.
9156  *
9157  * @params[in]
9158  *
9159  * @return ROK     - success
9160  *         RFAILED - failure
9161  *
9162  * ****************************************************************/
9163 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb)
9164 {
9165    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
9166    uint8_t   ret= RFAILED, ret1;
9167    uint8_t   elementCnt;
9168    uint8_t   idx, idx1, bufLen, duIdx;
9169    uint32_t  spCellId;
9170    DuDb      *targetDuDb = NULLP;
9171    F1AP_PDU_t           *f1apMsg = NULLP;
9172    UEContextSetupRequest_t *ueSetReq = NULLP;
9173    asn_enc_rval_t encRetVal;        /* Encoder return value */
9174    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
9175
9176    while(true)
9177    {
9178       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
9179
9180       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9181       if(f1apMsg == NULLP)
9182       {
9183          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9184          break;
9185       }
9186
9187       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
9188       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
9189       if(f1apMsg->choice.initiatingMessage == NULLP)
9190       {
9191          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
9192          break;
9193       }
9194
9195       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
9196       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
9197       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
9198
9199       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9200
9201       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9202          elementCnt = 7;
9203       else
9204       {
9205 #ifdef NR_DRX
9206          elementCnt = 12;
9207 #else
9208          elementCnt = 11;
9209 #endif
9210       }
9211       ueSetReq->protocolIEs.list.count = elementCnt;
9212       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
9213
9214       /* Initialize the UESetup members */
9215       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
9216
9217       if(ueSetReq->protocolIEs.list.array == NULLP)
9218       {
9219          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
9220          break;
9221       }
9222
9223       for(idx1=0; idx1<elementCnt; idx1++)
9224       {
9225          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
9226          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
9227          {
9228             break;
9229          }
9230       }
9231
9232       idx = 0;
9233
9234       /*GNB CU UE F1AP ID*/
9235       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
9236       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9237       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
9238       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
9239
9240       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9241       {
9242          /*GNB DU UE F1AP ID*/
9243          idx++;
9244          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
9245          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9246          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
9247          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
9248       }
9249
9250       /*Special Cell ID*/
9251       idx++;
9252       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
9253       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9254       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
9255       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9256       {
9257          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
9258          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
9259          /* Since we are supporting only one cell per DU, accessing 0th index to
9260           * get target cell info */
9261          spCellId = targetDuDb->cellCb[0].nrCellId;
9262       }
9263       else
9264          spCellId = ueCb->cellCb->nrCellId;
9265       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
9266       if(Nrcgiret != ROK)
9267       {
9268          break;
9269       }
9270
9271       /*Served Cell Index*/
9272       idx++;
9273       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9274       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9275       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9276       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9277
9278       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9279       {
9280          /*CellULConfigured*/
9281          idx++;
9282          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9283          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9284          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9285          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9286       }
9287
9288       /*CUtoDURRCContainer*/
9289       idx++;
9290       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9291       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9292       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9293       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9294       {
9295          break;
9296       }
9297
9298       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9299       {
9300          /*Drx cycle*/
9301 #ifdef NR_DRX
9302          idx++;
9303          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_DRXCycle;
9304          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9305          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRXCycle;
9306          if(BuildDrxCycle(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRXCycle) != ROK)
9307          {
9308             DU_LOG("\nERROR  -->  F1AP : Failed to build drx cycle");
9309             break;
9310          }
9311 #endif
9312          /*Special Cells to be SetupList*/
9313          idx++;
9314          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9315          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9316          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9317          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9318          if(SplCellListret != ROK)
9319          {
9320             break;
9321          }
9322       }
9323
9324       /*SRBs To Be Setup List*/
9325       idx++;
9326       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9327       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9328       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9329       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9330       if(SrbSetupret != ROK)
9331       {
9332          break;
9333       }
9334
9335       /*DRBs to Be Setup List*/
9336       idx++;
9337       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9338       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9339       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9340       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9341       if(ret1 != ROK)
9342       {
9343          break;
9344       }
9345
9346       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9347       {
9348          /* RRC delivery status request */
9349          idx++;
9350          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9351          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9352          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9353          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9354       }
9355
9356       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9357       idx++;
9358       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9359       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9360       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9361
9362       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9363       bufLen = 4;
9364       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9365       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9366             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9367       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9368       {
9369          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9370          break;
9371       }
9372       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9373       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9374
9375       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9376
9377       /* Encode the F1SetupRequest type as APER */
9378       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9379       encBufSize = 0;
9380       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9381
9382       /* Encode results */
9383       if(encRetVal.encoded == ENCODE_FAIL)
9384       {
9385          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9386                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9387          break;
9388       }
9389       else
9390       {
9391          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9392          for(int i=0; i< encBufSize; i++)
9393          {
9394             DU_LOG("%x",encBuf[i]);
9395          }
9396       }
9397
9398       /* Sending  msg  */
9399       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9400       {
9401          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9402          break;
9403       }
9404       ret = ROK;
9405       break;
9406    }
9407    FreeUeContextSetupReq(f1apMsg);
9408
9409    return ret;
9410 }/* End of BuildAndSendUeContextSetupReq*/
9411
9412 /**********************************************************************
9413  * @brief Function to extractTeId received in UE context setup Response
9414  *
9415  * @details
9416  *
9417  *    Function : extractTeId
9418  *
9419  *    Functionality:
9420  *         - Function to extract TeId
9421  *
9422  * @params[in]
9423  * @return ROK     - success
9424  *         RFAILED - failure
9425  *
9426  **********************************************************************/
9427 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9428 {
9429    uint8_t arrIdx = 0;
9430    uint32_t teId = 0;
9431    GTPTunnel_t *gtpDl = NULLP;
9432
9433    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9434    {
9435       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9436       {
9437          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9438          {
9439             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9440             if(gtpDl->gTP_TEID.size > 0)
9441             {
9442                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9443             }
9444             else
9445                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9446             return(teId);
9447          }
9448       }
9449    }
9450    return teId;
9451 }
9452
9453 /****************************************************************
9454  * @brief Function to add Drb tunnels
9455  *
9456  * @details
9457  *
9458  *    Function : addDrbTunnels
9459  *
9460  *    Functionality:
9461  *         - Function to add Drb tunnels
9462  *
9463  * @params[in]
9464  * @return ROK     - success
9465  *         RFAILED - failure
9466  *
9467  * ****************************************************************/
9468 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9469 {
9470    uint8_t ret = ROK;
9471    EgtpTnlEvt tnlEvt;
9472
9473    if(teId > MAX_TEID || teId < MIN_TEID)
9474    {
9475       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9476    }
9477    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9478    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9479    tnlEvt.lclTeid = teId;
9480    tnlEvt.remTeid = teId;
9481    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9482    if(ret != ROK)
9483    {
9484       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9485    }
9486    return ROK;
9487 }
9488
9489 /****************************************************************
9490  * @brief Function to process Drb Setup List
9491  *
9492  * @details
9493  *
9494  *    Function : procDrbSetupList
9495  *
9496  *    Functionality:
9497  *         - Function to process DRB Setup List
9498  *
9499  * @params[in]
9500  * @return ROK     - success
9501  *         RFAILED - failure
9502  *
9503  * ****************************************************************/
9504 uint8_t procDrbSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_Setup_List_t *drbSetupList)
9505 {
9506    uint8_t arrIdx = 0, drbIdx = 0;
9507    uint32_t teId = 0;
9508    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9509
9510    if(drbSetupList != NULLP)
9511    {
9512       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9513       {
9514          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9515          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9516          {
9517             /* extracting teId */
9518             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9519             if(teId > 0)
9520             {
9521                if(addDrbTunnels(duId, teId)== ROK)
9522                {
9523                   DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9524                }
9525                /* As per Spec 38.473, in UE COntext Response, Tunnel information
9526                 * are sent to CU for setting up of Tunnels in DL direction.
9527                 * Search for DRB ID in CU databse */
9528                for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
9529                {
9530                   if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_Setup_Item.dRBID)
9531                   {
9532                      fillTeIdString(3, teId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
9533                      break;
9534                   }
9535                }
9536             }
9537             else
9538                return RFAILED;
9539          }
9540       }
9541    }
9542    return ROK;
9543 }
9544
9545 /****************************************************************
9546  * @brief Function to process Ue Context Setup Response
9547  *
9548  * @details
9549  *
9550  *    Function : procUeContextSetupResponse
9551  *
9552  *    Functionality:
9553  *         - Function to process Ue Context Setup Response
9554  *
9555  * @params[in]
9556  * @return ROK     - success
9557  *         RFAILED - failure
9558  *
9559  * ****************************************************************/
9560 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9561 {
9562    uint8_t duIdx = 0, idx = 0, ueIdx = 0, rrcMsgType=0;
9563    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9564    DuDb *duDb = NULLP;
9565    CuUeCb *ueCb = NULLP;
9566    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9567    OCTET_STRING_t *duToCuRrcContainer;
9568
9569    SEARCH_DU_DB(duIdx, duId, duDb);
9570    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9571
9572    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9573    {
9574       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9575       {
9576           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9577              {
9578                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9579                break;
9580              }
9581           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9582              {
9583                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9584                 ueCb = &duDb->ueCb[duUeF1apId-1];
9585                 /* If ue context is not present in du db, then create UE context
9586                  * here. This flow is hit in case of UE handover where UE
9587                  * context is created before UE performs RACH on target DU */
9588                 if(ueCb->gnbDuUeF1apId == 0)
9589                 {
9590                    /* Creating UE context in target DU */
9591                    memset(ueCb, 0, sizeof(CuUeCb));
9592                    ueCb->cellCb = &duDb->cellCb[0];
9593                    ueCb->gnbDuUeF1apId = duUeF1apId;
9594                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9595                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9596                    ueCb->hoInfo.targetDuId = duId;
9597                    (duDb->numUe)++;
9598
9599                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9600                    ueCb->cellCb->numUe++;
9601                 }
9602                 break;
9603              }
9604           case ProtocolIE_ID_id_C_RNTI:
9605              {
9606                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9607                 break;
9608              }
9609           case ProtocolIE_ID_id_DRBs_Setup_List:
9610              {
9611                 /* Adding Tunnels for successful DRB */
9612                 procDrbSetupList(duId, ueCb, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9613                 break;
9614              }
9615          case ProtocolIE_ID_id_DUtoCURRCInformation:
9616              {
9617                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9618                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9619                    DUtoCURRCInformation.cellGroupConfig;
9620                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9621                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9622                 {
9623                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9624                    return RFAILED;
9625                 }
9626                 break;
9627              }
9628       }
9629    }
9630
9631    /* If the UE is in handover, UE context modification request is to be sent to
9632     * source DU once UE context setup response is received from target DU */
9633    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9634    {
9635       DuDb *srcDuDb = NULLP;
9636       CuUeCb *ueCbInSrcDu = NULLP;
9637
9638       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9639        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9640       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9641       {
9642          /* UE context setup response is received from target DU. Search all
9643           * DUs to find source DU except this target DU Id.*/
9644          if(cuCb.duInfo[duIdx].duId != duId)
9645          {
9646             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9647             {
9648                /* Check following:
9649                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9650                 * received in UE context setup response since CU UE F1AP ID does not
9651                 * change for UE in handover.
9652                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9653                 */
9654                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9655                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9656                {
9657                   srcDuDb = &cuCb.duInfo[duIdx];
9658                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9659
9660                   /* Store source DU info in the new UE context created in
9661                    * tareget DU */
9662                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9663
9664                   /* Copy the received container to UeCb */
9665                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9666
9667                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9668                   {
9669                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9670                      return RFAILED;
9671                   }
9672                   break;
9673                }
9674             }
9675          }
9676          if(srcDuDb && ueCbInSrcDu)
9677             break;
9678       }
9679    }
9680    else
9681    {
9682       ueCb->f1apMsgDb.dlRrcMsgCount++;
9683       rrcMsgType = setDlRRCMsgType(ueCb);
9684
9685       DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC reconfiguration");
9686       if(BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB1, rrcMsgType) != ROK)
9687       {
9688          DU_LOG("\nINFO  -->  F1AP: Failed to build and send DL RRC MSG for RRC reconfiguration");
9689          return RFAILED;
9690       }
9691    }
9692
9693    return ROK;
9694 }
9695
9696 /****************************************************************
9697  * @brief Function to process Ul Rrc Msg received from DU
9698  *
9699  * @details
9700  *
9701  *    Function : procUlRrcMsg
9702  *
9703  *    Functionality:
9704  *         - Function to process Ul Rrc Msg received from DU
9705  *
9706  * @params[in]
9707  * @return ROK     - success
9708  *         RFAILED - failure
9709  *
9710  * ****************************************************************/
9711
9712 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9713 {
9714    uint8_t  idx = 0, ret = ROK, srbId = 0, rrcMsgType = 0, duIdx=0;
9715    uint8_t  *rrcContainer = NULLP;
9716    uint16_t rrcContLen = 0;
9717    uint32_t cuUeF1apId = 0, duUeF1apId = 0;
9718    DuDb     *duDb = NULLP;
9719    CuUeCb   *ueCb = NULLP;
9720    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9721
9722    ret = ROK;
9723    SEARCH_DU_DB(duIdx, duId, duDb);
9724    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9725
9726    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9727    {
9728       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9729       {
9730          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9731             {
9732                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9733                break;
9734             }
9735          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9736             {
9737                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9738                break;
9739             }
9740          case ProtocolIE_ID_id_SRBID:
9741             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9742             break;
9743
9744          case ProtocolIE_ID_id_RRCContainer:
9745             {
9746                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9747                CU_ALLOC(rrcContainer, rrcContLen);
9748                if(!rrcContainer)
9749                {
9750                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9751                   return RFAILED;
9752                }
9753                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9754
9755                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9756                {
9757                   uint8_t ueIdx = 0;
9758                   uint8_t srcDuId = duDb->ueCb[duUeF1apId-1].hoInfo.sourceDuId;
9759                   DuDb *srcDuDb = NULLP;
9760
9761                   /* In target DU DB, mark UE as active and delete HO info */
9762                   duDb->ueCb[duUeF1apId-1].state = UE_ACTIVE;
9763                   memset(&duDb->ueCb[duUeF1apId-1].hoInfo, 0, sizeof(HandoverInfo));
9764
9765                   /* Release UE context in source DU because the UE is now
9766                    * attached to target DU */
9767                   SEARCH_DU_DB(duIdx, srcDuId, srcDuDb);
9768                   for(ueIdx = 0; ueIdx < srcDuDb->numUe; ueIdx++)
9769                   {
9770                      if(srcDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
9771                      {
9772                         ret = BuildAndSendUeContextReleaseCommand(srcDuId, srcDuDb->ueCb[ueIdx].gnbCuUeF1apId, srcDuDb->ueCb[ueIdx].gnbDuUeF1apId);
9773                         if(ret != ROK)
9774                         {
9775                            DU_LOG("\nINFO  -->  F1AP: Failed to build and send UE context release command to source DU Id [%d]", srcDuId);
9776                         }
9777                         break;
9778                      }
9779                   }
9780                   return ret;
9781                }
9782                break;
9783             }
9784
9785          default:
9786             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9787             break;
9788       }
9789    }
9790
9791    if(srbId == 1)
9792    {
9793       ueCb = &duDb->ueCb[duUeF1apId-1];
9794       ueCb->f1apMsgDb.dlRrcMsgCount++;
9795       rrcMsgType = setDlRRCMsgType(ueCb);
9796       if(rrcMsgType == RRC_SETUP_COMPLETE)
9797       {
9798          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for NAS Security Mode Command");
9799          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9800       }
9801       if(rrcMsgType == NAS_SECURITY_MODE_COMPLETE)
9802       {
9803          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Security Mode Command");
9804          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9805       }
9806       else if(rrcMsgType == RRC_SECURITY_MODE_COMPLETE)
9807       {
9808          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9809          BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9810       }
9811       else if(rrcMsgType == REGISTRATION_COMPLETE)
9812       {
9813          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Request");
9814          ret = BuildAndSendUeContextSetupReq(duId, ueCb);
9815       }
9816       else if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9817       {
9818          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9819          BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9820       }
9821    }
9822    return ret;
9823 }
9824
9825 /****************************************************************
9826  * @brief Build And Send F1ResetAck
9827  *
9828  * @details
9829  *
9830  *    Function : FreeF1ResetAck
9831  *
9832  *    Functionality:
9833  *         - Build And Send  F1ResetRSP
9834  *
9835  *  @params[in]
9836  * @return ROK     - success
9837  *         RFAILED - failure
9838  *
9839  * ****************************************************************/
9840 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9841 {
9842    uint8_t idx;
9843    ResetAcknowledge_t *f1ResetAck;
9844
9845    if(f1apMsg)
9846    {
9847       if(f1apMsg->choice.successfulOutcome)
9848       {
9849          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9850
9851          if(f1ResetAck->protocolIEs.list.array)
9852          {
9853             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9854             {
9855                if(f1ResetAck->protocolIEs.list.array[idx])
9856                {
9857                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9858                }
9859             }
9860             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9861          }
9862          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9863       }
9864       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9865    }
9866 }
9867
9868 /****************************************************************
9869  * @brief Build And Send F1ResetAck
9870  *
9871  * @details
9872  *
9873  *    Function : BuildAndSendF1ResetAck
9874  *
9875  *    Functionality:
9876  *         - Build And Send  F1ResetRSP
9877  *
9878  *  @params[in]
9879  * @return ROK     - success
9880  *         RFAILED - failure
9881  *
9882  * ****************************************************************/
9883
9884 uint8_t BuildAndSendF1ResetAck()
9885 {
9886    uint8_t                idx = 0;
9887    uint8_t                elementCnt = 0;
9888    uint8_t                ret = RFAILED;
9889    F1AP_PDU_t             *f1apMsg = NULL;
9890    ResetAcknowledge_t     *f1ResetAck = NULLP;
9891    asn_enc_rval_t         encRetVal;
9892    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9893
9894    do{
9895       /* Allocate the memory for F1ResetRequest_t */
9896       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9897       if(f1apMsg == NULLP)
9898       {
9899          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9900          break;
9901       }
9902
9903       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9904
9905       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9906       if(f1apMsg->choice.successfulOutcome == NULLP)
9907       {
9908          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9909          break;
9910       }
9911
9912       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9913       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9914       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9915       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9916
9917       elementCnt = 1;
9918
9919       f1ResetAck->protocolIEs.list.count = elementCnt;
9920       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9921
9922       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9923       if(f1ResetAck->protocolIEs.list.array == NULLP)
9924       {
9925          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9926          break;
9927       }
9928
9929       for(idx=0; idx<elementCnt; idx++)
9930       {
9931          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9932          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9933          {
9934             break;
9935          }
9936       }
9937       /*TransactionID*/
9938       idx = 0;
9939       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9940       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9941       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9942       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9943
9944       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9945
9946       /* Encode the F1SetupRequest type as UPER */
9947       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9948       encBufSize = 0;
9949       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9950
9951       /* Check encode results */
9952       if(encRetVal.encoded == ENCODE_FAIL)
9953       {
9954          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9955                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9956          break;
9957       }
9958       else
9959       {
9960          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9961          for(int i=0; i< encBufSize; i++)
9962          {
9963             DU_LOG("%x",encBuf[i]);
9964          }
9965       }
9966
9967       /* Sending msg */
9968       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9969       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9970       {
9971          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9972          break;
9973       }
9974
9975       ret = ROK;
9976       break;
9977    }while(true);
9978
9979    FreeF1ResetAck(f1apMsg);
9980    return ret;
9981 }
9982
9983 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9984 {
9985    uint8_t arrIdx =0;
9986
9987    if(ulInfo->list.array)
9988    {
9989       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9990       {
9991          if(ulInfo->list.array[arrIdx])
9992          {
9993             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9994             {
9995                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9996                {
9997                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9998                   {
9999                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10000                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10001                      gTPTunnel->gTP_TEID.size);
10002                   }
10003                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10004                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10005                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10006                }
10007                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10008                sizeof(GTPTunnel_t));
10009             }
10010             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10011          }
10012       }
10013       CU_FREE(ulInfo->list.array,ulInfo->list.size);
10014    }
10015 }
10016
10017 /*******************************************************************
10018 *
10019 * @brief Deletes the EGTP tunnel
10020 *
10021 * @details
10022 *
10023 *    Function : deleteEgtpTunnel
10024 *
10025 *    Functionality: Deletes the EGTP tunnel
10026 *
10027 * @params[in] uint8_t *buf
10028 *
10029 * @return ROK     - success
10030 *         RFAILED - failure
10031 *
10032 * ****************************************************************/
10033 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
10034 {
10035    uint32_t teId = 0;
10036    EgtpTnlEvt tnlEvt;
10037
10038    teIdStringToInt(buf, &teId);
10039    if(teId > MAX_TEID || teId < MIN_TEID)
10040    {
10041       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
10042       return RFAILED;
10043    }
10044    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
10045    tnlEvt.action = EGTP_TNL_MGMT_DEL;
10046    tnlEvt.lclTeid = teId;
10047    tnlEvt.remTeid = teId;
10048    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
10049    {
10050       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
10051    }
10052    return ROK;
10053 }
10054
10055 /*******************************************************************
10056 *
10057 * @brief Builds the Uplink Tunnel Info
10058 *
10059 * @details
10060 *
10061 *    Function : BuildUlTnlInfoforSetupMod
10062 *
10063 *    Functionality: Constructs the UL TnlInfo For DRB list
10064 *
10065 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10066 *
10067 * @return ROK     - success
10068 *         RFAILED - failure
10069 *
10070 * ****************************************************************/
10071 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
10072 {
10073    uint8_t arrIdx;
10074    uint8_t ulCnt;
10075
10076    ulCnt = 1;
10077    ulInfo->list.count = ulCnt;
10078    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
10079    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
10080    if(ulInfo->list.array == NULLP)
10081    {
10082       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10083       return RFAILED;
10084    }
10085    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
10086    {
10087       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
10088       if(ulInfo->list.array[arrIdx] == NULLP)
10089       {
10090          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10091          return RFAILED;
10092       }
10093    }
10094
10095    arrIdx = 0;
10096    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
10097    UPTransportLayerInformation_PR_gTPTunnel;
10098
10099    /*GTP TUNNEL*/
10100    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
10101          sizeof(GTPTunnel_t));
10102    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
10103    {
10104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10105       return RFAILED;
10106    }
10107    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10108       transportLayerAddress.size        = 4*sizeof(uint8_t);
10109    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10110          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
10111          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10112    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10113          transportLayerAddress.buf == NULLP)
10114    {
10115       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10116       return RFAILED;
10117    }
10118
10119    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10120       transportLayerAddress.buf[0] = 192;
10121    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10122       transportLayerAddress.buf[1] = 168;
10123    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10124       transportLayerAddress.buf[2] = 130;
10125    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10126       transportLayerAddress.buf[3] = 82;
10127    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10128       transportLayerAddress.bits_unused = 0;
10129
10130    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
10131    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
10132    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
10133    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
10134
10135    /*GTP TEID*/
10136    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
10137       = 4 * sizeof(uint8_t);
10138    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10139          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
10140          gTPTunnel->gTP_TEID.size);
10141    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10142          == NULLP)
10143    {
10144       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
10145       return RFAILED;
10146    }
10147    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10148       gTP_TEID.buf[0] = 0;
10149    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10150       gTP_TEID.buf[1] = 0;
10151    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10152       gTP_TEID.buf[2] = 0;
10153    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
10154    {
10155      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
10156       * fetched based on the Drb Id */
10157
10158      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
10159       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
10160                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
10161    }
10162    else
10163    {
10164       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10165         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
10166    }
10167
10168    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
10169    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
10170    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
10171    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
10172    return ROK;
10173 }/*End of BuildULTnlInfo*/
10174
10175 /*******************************************************************
10176 *
10177 * @brief freeing the DRB item
10178 *
10179 * @details
10180 *
10181 *    Function : FreeDrbItem
10182 *
10183 *    Functionality: freeing the DRB item
10184 *
10185 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10186 *
10187 * @return ROK     - success
10188 *         RFAILED - failure
10189 *
10190 * ****************************************************************/
10191
10192 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
10193 {
10194    uint8_t arrIdx =0;
10195    SNSSAI_t *snssai =NULLP;
10196    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10197
10198    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10199    switch(drbItem->qoSInformation.present)
10200    {
10201       case QoSInformation_PR_NOTHING:
10202          break;
10203       case QoSInformation_PR_eUTRANQoS:
10204          {
10205             if(drbItem->qoSInformation.choice.eUTRANQoS)
10206             {
10207                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10208             }
10209             break;
10210          }
10211       case QoSInformation_PR_choice_extension:
10212          {
10213             if(drbItem->qoSInformation.choice.choice_extension)
10214             {
10215                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10216
10217                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10218                if(snssai->sST.buf)
10219                {
10220                   CU_FREE(snssai->sST.buf,snssai->sST.size);
10221                }
10222                if(snssai->sD)
10223                {
10224                   if(snssai->sD->buf)
10225                   {
10226                      CU_FREE(snssai->sD->buf,snssai->sD->size);
10227                   }
10228                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10229                }
10230
10231                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10232                if(flowMap->list.array)
10233                {
10234                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10235                   {
10236                      if(flowMap->list.array[arrIdx] )
10237                      {
10238                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10239                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10240                      }
10241                   }
10242                   CU_FREE(flowMap->list.array,flowMap->list.size);
10243                }
10244
10245                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10246             }
10247             break;
10248          }
10249
10250    }
10251    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10252    if(drbItem->uLConfiguration)
10253    {
10254       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10255    }
10256 }
10257
10258 /*******************************************************************
10259 *
10260 * @brief filling the DRB setup Mod item
10261 *
10262 * @details
10263 *
10264 *    Function : FillDrbItemToSetupMod
10265 *
10266 *    Functionality: filling the DRB setup Mod item
10267 *
10268 *
10269 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10270 *
10271 * @return ROK     - success
10272 *         RFAILED - failure
10273 *
10274 * ****************************************************************/
10275
10276 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
10277 {
10278    uint8_t ret = ROK;
10279
10280    /*Drb Id */
10281    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
10282    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
10283
10284    /*qoSInformation*/
10285    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
10286
10287    switch(drbItem->qoSInformation.present)
10288    {
10289       case QoSInformation_PR_NOTHING:
10290       {
10291          break;
10292       }
10293       case QoSInformation_PR_eUTRANQoS:
10294       {
10295
10296          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10297          if(drbItem->qoSInformation.choice.eUTRANQoS)
10298          {
10299             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10300             return RFAILED;
10301          }
10302          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10303          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10304             PriorityLevel_no_priority;
10305
10306          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10307             Pre_emptionCapability_may_trigger_pre_emption;
10308
10309          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10310             Pre_emptionVulnerability_pre_emptable;
10311
10312          break;
10313       }
10314       case QoSInformation_PR_choice_extension:
10315       {
10316          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10317          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10318          {
10319             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10320             return RFAILED;
10321          }
10322
10323          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10324          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10325          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10326          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10327            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10328          if(ret != ROK)
10329          {
10330             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10331             return RFAILED;
10332          }
10333
10334          /*SNSSAI*/
10335          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10336                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10337          if(ret != ROK)
10338          {
10339             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10340             return RFAILED;
10341          }
10342
10343          /*Flows mapped to DRB List*/
10344          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10345                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10346           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10347          if(ret != ROK)
10348          {
10349             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10350             return RFAILED;
10351          }
10352       }
10353    }
10354
10355    /*ULUPTNLInformation To Be Setup List*/
10356    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10357       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10358    if(ret != ROK)
10359    {
10360       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10361       return RFAILED;
10362    }
10363
10364    /*RLCMode*/
10365    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10366    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10367
10368    ueCb->numDrb++;
10369    return ROK;
10370 }
10371
10372 /*******************************************************************
10373 *
10374 * @brief Builds the DRB to be Setup Mod ItemIes
10375 *
10376 * @details
10377 *
10378 *    Function : FillDrbItemList
10379 *
10380 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10381 *
10382 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10383 *
10384 * @return ROK     - success
10385 *         RFAILED - failure
10386 *
10387 * ****************************************************************/
10388
10389 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10390 {
10391    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10392    drbItemIe->criticality = Criticality_reject;
10393    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10394
10395    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10396    {
10397       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10398       return RFAILED;
10399    }
10400    return ROK;
10401 }
10402 /*******************************************************************
10403 *
10404 * @brief free the DRB to be Setup Mod list
10405 *
10406 * @details
10407 *
10408 *    Function : FreeDrbToBeSetupModList
10409 *
10410 *    Functionality: free the DRB to be Setup Mod list
10411 *
10412 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10413 *
10414 * @return ROK     - success
10415 *         RFAILED - failure
10416 *
10417 * ****************************************************************/
10418 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10419 {
10420    uint8_t arrIdx =0;
10421    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10422
10423    if(drbSet->list.array)
10424    {
10425       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10426       {
10427          if(drbSet->list.array[arrIdx] != NULLP)
10428          {
10429             if(arrIdx == 0)
10430             {
10431                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10432                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10433             }
10434             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10435          }
10436       }
10437       CU_FREE(drbSet->list.array, drbSet->list.size);
10438    }
10439
10440 }
10441
10442 /*******************************************************************
10443 *
10444 * @brief Builds the DRB to be Setup Mod list
10445 *
10446 * @details
10447 *
10448 *    Function : BuildDrbToBeSetupList
10449 *
10450 *    Functionality: Constructs the DRB to be Setup Mod list
10451 *
10452 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10453 *
10454 * @return ROK     - success
10455 *         RFAILED - failure
10456 *
10457 * ****************************************************************/
10458
10459 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10460 {
10461    uint8_t ret = ROK;
10462    uint8_t arrIdx =0;
10463    uint8_t drbCnt =0;
10464
10465    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10466    drbSet->list.count = drbCnt;
10467    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10468    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10469    if(drbSet->list.array == NULLP)
10470    {
10471       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10472       return  RFAILED;
10473    }
10474
10475    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10476    {
10477       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10478       if(drbSet->list.array[arrIdx] == NULLP)
10479       {
10480          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10481          return  RFAILED;
10482       }
10483
10484       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10485       if(ret != ROK)
10486       {
10487          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10488       }
10489    }
10490
10491    return ret;
10492 }
10493
10494 /*******************************************************************
10495 *
10496 * @brief Filling the DRB to be modified item
10497 *
10498 * @details
10499 *
10500 *    Function : FillDrbToBeModItem
10501 *
10502 *    Functionality: filling the DRB to be modified item
10503 *
10504 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10505 *
10506 * @return ROK     - success
10507 *         RFAILED - failure
10508 *
10509 * ****************************************************************/
10510
10511 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10512 {
10513    uint8_t ret = ROK;
10514    uint drbIdx=0;
10515    DrbInfo *drbToBeMod;
10516
10517    /*Drb Id */
10518    drbItem->dRBID = DRB2 + arrIdx;
10519
10520    /* Search for DRB ID in CU databse */
10521    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10522    {
10523       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10524       {
10525          drbToBeMod = &ueCb->drbList[drbIdx];
10526          break;
10527       }
10528    }
10529
10530    /*qoSInformation*/
10531    drbItem->qoSInformation = NULLP;
10532    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10533    if(drbItem->qoSInformation != NULLP)
10534    {
10535       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10536
10537       switch(drbItem->qoSInformation->present)
10538       {
10539          case QoSInformation_PR_NOTHING:
10540             {
10541                break;
10542             }
10543          case QoSInformation_PR_eUTRANQoS:
10544             {
10545
10546                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10547                if(drbItem->qoSInformation->choice.eUTRANQoS)
10548                {
10549                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10550                   return RFAILED;
10551                }
10552                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10553                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10554                   PriorityLevel_no_priority;
10555
10556                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10557                   Pre_emptionCapability_may_trigger_pre_emption;
10558
10559                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10560                   Pre_emptionVulnerability_pre_emptable;
10561
10562                break;
10563             }
10564          case QoSInformation_PR_choice_extension:
10565             {
10566                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10567                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10568                {
10569                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10570                   return RFAILED;
10571                }
10572
10573                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10574                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10575                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10576                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10577                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10578                if(ret != ROK)
10579                {
10580                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10581                   return RFAILED;
10582                }
10583
10584                /*SNSSAI*/
10585                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10586                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10587                if(ret != ROK)
10588                {
10589                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10590                   return RFAILED;
10591                }
10592
10593                /*Flows mapped to DRB List*/
10594                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10595                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10596                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10597                if(ret != ROK)
10598                {
10599                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10600                   return RFAILED;
10601                }
10602             }
10603       }
10604    }/* End of QoS */
10605
10606    /*ULUPTNLInformation To Be Setup List*/
10607    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10608             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10609    if(ret != ROK)
10610    {
10611       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10612       return RFAILED;
10613    }
10614    return ROK;
10615 }
10616
10617 /*******************************************************************
10618 *
10619 * @brief Builds the DRB to be modified Item IE
10620 *
10621 * @details
10622 *
10623 *    Function : FillDrbToBeModItemList
10624 *
10625 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10626 *
10627 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10628 *
10629 * @return ROK     - success
10630 *         RFAILED - failure
10631 *
10632 * ****************************************************************/
10633
10634 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10635 {
10636    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10637    drbItemIe->criticality = Criticality_reject;
10638    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10639    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10640    {
10641       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10642       return RFAILED;
10643    }
10644
10645    return ROK;
10646 }
10647
10648 /*******************************************************************
10649 *
10650 * @brief Builds the DRB to be modified list
10651 *
10652 * @details
10653 *
10654 *    Function : BuildDrbToBeModList
10655 *
10656 *    Functionality: Constructs the DRB to be modified list
10657 *
10658 * @params[in] DRBs_ToBeModified_List_t *drbSet
10659 *
10660 * @return ROK     - success
10661 *         RFAILED - failure
10662 *
10663 * ****************************************************************/
10664
10665 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10666 {
10667    uint8_t ret = ROK;
10668    uint8_t arrIdx =0;
10669    uint8_t drbCnt =0;
10670
10671    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10672    drbSet->list.count = drbCnt;
10673    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10674    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10675    if(drbSet->list.array == NULLP)
10676    {
10677       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10678       return  RFAILED;
10679    }
10680    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10681    {
10682       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10683       if(drbSet->list.array[arrIdx] == NULLP)
10684       {
10685          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10686          return  RFAILED;
10687       }
10688
10689       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10690       if(ret != ROK)
10691       {
10692          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10693       }
10694    }
10695
10696    return ret;
10697 }
10698
10699 /*******************************************************************
10700 *
10701 * @brief freeing the DRB  item
10702 *
10703 * @details
10704 *
10705 *    Function : FreeModifiedDrbItem
10706 *
10707 *    Functionality: freeing the DRB 2 item
10708 *
10709 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10710 *
10711 * @return ROK     - success
10712 *         RFAILED - failure
10713 *
10714 * ****************************************************************/
10715
10716 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10717 {
10718    uint8_t arrIdx =0;
10719    SNSSAI_t *snssai =NULLP;
10720    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10721
10722    if(drbItem->qoSInformation != NULLP)
10723    {
10724       switch(drbItem->qoSInformation->present)
10725       {
10726          case QoSInformation_PR_NOTHING:
10727             break;
10728          case QoSInformation_PR_eUTRANQoS:
10729             {
10730                if(drbItem->qoSInformation->choice.eUTRANQoS)
10731                {
10732                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10733                }
10734                break;
10735             }
10736          case QoSInformation_PR_choice_extension:
10737             {
10738                if(drbItem->qoSInformation->choice.choice_extension)
10739                {
10740                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10741
10742                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10743                   if(snssai->sST.buf)
10744                   {
10745                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10746                   }
10747                   if(snssai->sD)
10748                   {
10749                      if(snssai->sD->buf)
10750                      {
10751                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10752                      }
10753                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10754                   }
10755
10756                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10757                   if(flowMap->list.array)
10758                   {
10759                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10760                      {
10761                         if(flowMap->list.array[arrIdx] )
10762                         {
10763                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10764                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10765                         }
10766                      }
10767                      CU_FREE(flowMap->list.array,flowMap->list.size);
10768                   }
10769
10770                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10771                }
10772                break;
10773             }
10774       }
10775    }
10776    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10777    if(drbItem->uLConfiguration)
10778    {
10779       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10780    }
10781 }
10782
10783 /*******************************************************************
10784 *
10785 * @brief free the DRB to be modfified list
10786 *
10787 * @details
10788 *
10789 *    Function : FreeDrbToBeModifiedList
10790 *
10791 *    Functionality: free the DRB to be Setup Mod list
10792 *
10793 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10794 *
10795 * @return ROK     - success
10796 *         RFAILED - failure
10797 *
10798 * ****************************************************************/
10799 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10800 {
10801    uint8_t arrIdx =0;
10802    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10803
10804    if(drbSet->list.array)
10805    {
10806       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10807       {
10808          if(drbSet->list.array[arrIdx] != NULLP)
10809          {
10810             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10811             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10812             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10813          }
10814       }
10815       CU_FREE(drbSet->list.array, drbSet->list.size);
10816    }
10817
10818 }
10819
10820 /*******************************************************************
10821  *
10822  * @brief  free the UeContextModification Request
10823  *
10824  * @details
10825  *
10826  *    Function : FreeUeContextModicationRequest
10827  *
10828  *    Functionality : deallocation of memory allocated in UeContextModiification
10829  request
10830  *
10831  * @params[in] F1AP_PDU_t *f1apMsg
10832  *
10833  * @return void
10834 *
10835 * ****************************************************************/
10836 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10837 {
10838    uint8_t arrIdx =0 , ieId=0;
10839    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10840
10841    if(f1apMsg)
10842    {
10843       if(f1apMsg->choice.initiatingMessage)
10844       {
10845          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10846          if(ueContextModifyReq->protocolIEs.list.array)
10847          {
10848             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10849             {
10850                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10851                {
10852                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10853                   switch(ieId)
10854                   {
10855                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10856                         break;
10857                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10858                         break;
10859                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10860                         {
10861                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10862                                  choice.DRBs_ToBeSetupMod_List);
10863                            break;
10864                         }
10865                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10866                         {
10867                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10868                                  choice.DRBs_ToBeModified_List);
10869                            break;
10870                         }
10871                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10872                         break;
10873                     case ProtocolIE_ID_id_RRCContainer:
10874                     {
10875                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10876                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10877                     }
10878
10879                   }
10880                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10881                }
10882             }
10883             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10884          }
10885          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10886       }
10887       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10888    }
10889 }
10890
10891 /*******************************************************************
10892  *
10893  * @brief Builds the Ue Context Modification Req
10894  *
10895  * @details
10896  *
10897  *    Function : BuildAndSendUeContextModificationReq
10898  *
10899  *    Functionality: Constructs the Ue Context Modification Req
10900  *
10901  * @params[in]
10902  *
10903  * @return ROK     - success
10904  *         RFAILED - failure
10905  *
10906  * ****************************************************************/
10907 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10908 {
10909    uint8_t    ieIdx = 0;
10910    uint8_t    elementCnt = 0;
10911    uint8_t    ret = RFAILED;
10912    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10913    F1AP_PDU_t *f1apMsg = NULLP;
10914    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10915    asn_enc_rval_t         encRetVal;
10916    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10917    while(1)
10918    {
10919       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10920       if(f1apMsg == NULLP)
10921       {
10922          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10923          break;
10924       }
10925
10926       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10927
10928       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10929       if(f1apMsg->choice.initiatingMessage == NULLP)
10930       {
10931          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10932          break;
10933       }
10934       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10935       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10936       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10937
10938       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10939
10940       if(action == MODIFY_UE)
10941          elementCnt = 5;
10942       else if(action == QUERY_CONFIG)
10943          elementCnt = 3;
10944       else if(action == RRC_RECONFIG_COMPLETE_IND)
10945          elementCnt = 3;
10946       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10947          elementCnt = 5;
10948
10949 #ifdef NR_DRX
10950       if(DRX_TO_BE_RELEASE)
10951          elementCnt++;
10952 #endif
10953       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10954       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10955
10956       /* Initialize the UE context modification members */
10957       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10958       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10959       {
10960          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10961          break;
10962       }
10963
10964       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10965       {
10966          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10967          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10968          {
10969             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10970             break;
10971          }
10972       }
10973
10974       ieIdx=0;
10975       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10976       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10977       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10978                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10979       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10980
10981       ieIdx++;
10982       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10983       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10984       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10985                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10986       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10987
10988       if(action == MODIFY_UE)
10989       {
10990          /* DRB to be setup list */
10991          ieIdx++;
10992          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10993          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10994          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10995                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10996          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10997                   value.choice.DRBs_ToBeSetupMod_List));
10998
10999          /* DRB to be modified list */
11000          ieIdx++;
11001          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
11002          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11003          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
11004                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
11005          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
11006                   value.choice.DRBs_ToBeModified_List));
11007
11008          /* TODO: DRB to be release list */
11009
11010          if(ret != ROK)
11011          {
11012             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
11013             break;
11014          }
11015
11016          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
11017       }
11018       else if(action == QUERY_CONFIG)
11019       {
11020          ieIdx++;
11021          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
11022          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11023          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11024             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
11025          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
11026       }
11027       else if(action == RRC_RECONFIG_COMPLETE_IND)
11028       {
11029          ieIdx++;
11030          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
11031          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11032          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11033             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
11034          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
11035             RRCReconfigurationCompleteIndicator_true;
11036       }
11037       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
11038       {
11039          ieIdx++;
11040          if(action == STOP_DATA_TX)
11041          {
11042             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11043             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11044             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11045             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11046             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11047             TransmissionActionIndicator_stop;
11048          }
11049          else if (action == RESTART_DATA_TX)
11050          {
11051             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
11052             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11053             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11054             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
11055             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
11056             TransmissionActionIndicator_restart;
11057          }
11058
11059          ieIdx++;
11060          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11061          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11062          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
11063          UEContextModificationRequestIEs__value_PR_RRCContainer;
11064          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
11065          {
11066             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
11067             return RFAILED;
11068          }
11069
11070          /* RRC delivery status request */
11071          ieIdx++;
11072          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
11073          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11074          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
11075          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
11076       }
11077
11078 #ifdef NR_DRX
11079       if(DRX_TO_BE_RELEASE)
11080       {
11081          /* DRX Configuration Indicator */
11082          ieIdx++;
11083          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRXConfigurationIndicator;
11084          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11085          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_DRXConfigurationIndicator;
11086          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.DRXConfigurationIndicator = DRXConfigurationIndicator_release;
11087          ueCb->drxCfgPresent = false;
11088          memset(&ueCb->drxCfg, 0, sizeof(DrxCfg));
11089       }
11090 #endif
11091
11092       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11093
11094       /* Encode the F1SetupRequest type as APER */
11095       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11096       encBufSize = 0;
11097       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11098
11099       /* Encode results */
11100       if(encRetVal.encoded == ENCODE_FAIL)
11101       {
11102          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
11103                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11104          break;
11105       }
11106       else
11107       {
11108          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
11109 #if 0
11110          /* This for loop was going into an infinite loop even though encBufSize
11111           * has a small value. Hence commented this
11112           */
11113          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11114          {
11115             DU_LOG("%x",encBuf[ieIdx]);
11116          }
11117 #endif
11118       }
11119
11120       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11121       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11122       {
11123          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
11124          break;
11125       }
11126
11127       ret = ROK;
11128       break;
11129
11130    }
11131    FreeUeContextModicationRequest(f1apMsg);
11132    return ret;
11133 }
11134
11135 /*****************************************************************i
11136  *
11137 * @brief Free memory allocated for UE Context Release Command
11138 *
11139 * @details
11140 *
11141 *    Function : FreeUeContextReleaseCommand
11142 *
11143 *    Functionality:
11144 *         - Free memory allocated for UE Context Release Command
11145 *
11146 * @params[in] F1AP_PDU_t *f1apMsg
11147 * @return void
11148 *
11149 * *************************************************************/
11150 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
11151 {
11152    uint8_t ieIdx;
11153    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
11154
11155    if(f1apMsg)
11156    {
11157       if(f1apMsg->choice.initiatingMessage)
11158       {
11159          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11160          if(ueReleaseCommand->protocolIEs.list.array)
11161          {
11162             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
11163             {
11164                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11165             }
11166             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
11167          }
11168          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11169       }
11170       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11171    }
11172 }
11173 /*******************************************************************
11174  *
11175  * @brief Builds the Ue Context Release Command
11176  *
11177  * @details
11178 *
11179 *    Function : BuildAndSendUeContextReleaseCommand
11180 *
11181 *    Functionality: Constructs the Ue Context Release Command
11182 *
11183 * @params[in]
11184 *
11185 * @return ROK     - success
11186 *         RFAILED - failure
11187 *
11188 * ****************************************************************/
11189 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
11190 {
11191    bool       memAllocFailed = false;
11192    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
11193    DuDb *duDb;
11194    CuUeCb *ueCb;
11195    F1AP_PDU_t *f1apMsg = NULLP;
11196    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
11197
11198    asn_enc_rval_t         encRetVal;
11199    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
11200
11201    while(true)
11202    {
11203       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11204       if(f1apMsg == NULLP)
11205       {
11206          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
11207          break;
11208       }
11209
11210       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11211
11212       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11213       if(f1apMsg->choice.initiatingMessage == NULLP)
11214       {
11215          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
11216          break;
11217       }
11218       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
11219       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11220       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
11221
11222       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
11223
11224       SEARCH_DU_DB(duIdx, duId, duDb);
11225       ueCb = &duDb->ueCb[duUeF1apId-1];
11226       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11227          elementCnt = 3;
11228       else
11229          elementCnt = 4;
11230
11231       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
11232       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
11233
11234       /* Initialize the UE context modification members */
11235       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
11236       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
11237       {
11238          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
11239          break;
11240       }
11241
11242       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11243       {
11244          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
11245          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
11246          {
11247             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
11248             memAllocFailed = true;
11249             break;
11250          }
11251       }
11252
11253       if(memAllocFailed == true)
11254       {
11255          break;
11256       }
11257
11258       ieIdx=0;
11259       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11260       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11261       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11262       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
11263       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
11264
11265       ieIdx++;
11266       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11267       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11268       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11269       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
11270       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
11271
11272       /* Cause of UE context release */
11273       ieIdx++;
11274       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
11275       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11276       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
11277                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
11278       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11279       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
11280                                                                                                      CauseRadioNetwork_normal_release;
11281       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11282       {
11283          /* RRC Container for RRC release */
11284          ieIdx++;
11285          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
11286          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11287          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
11288                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
11289          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
11290          bufLen =7;
11291          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
11292          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
11293                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
11294          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
11295          {
11296             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
11297             break;
11298          }
11299          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
11300          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
11301       }
11302       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11303
11304       /* Encode the UE Context Release Command type as APER */
11305       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11306       encBufSize = 0;
11307       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11308             encBuf);
11309
11310       /* Encode results */
11311       if(encRetVal.encoded == ENCODE_FAIL)
11312       {
11313          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11314                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11315          break;
11316       }
11317       else
11318       {
11319          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
11320          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11321          {
11322             DU_LOG("%x",encBuf[ieIdx]);
11323          }
11324       }
11325
11326       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11327       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11328       {
11329          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11330          break;
11331       }
11332
11333       ret = ROK;
11334       break;
11335
11336    }
11337    FreeUeContextReleaseCommand(f1apMsg);
11338    return ret;
11339 }
11340 /*******************************************************************
11341 *
11342 * @brief process Ue context release request
11343 *
11344 * @details
11345 *
11346 *    Function : procUeContextReleaseReq
11347 *
11348 *    Functionality:
11349 *         - process Ue context release request
11350 *
11351 * @params[in] F1AP_PDU_t *f1apMsg
11352 * @return ROK     - success
11353 *         RFAILED - failure
11354 *
11355 * ****************************************************************/
11356 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11357 {
11358    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11359
11360    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11361    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11362
11363    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11364    {
11365       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11366       {
11367          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11368             {
11369                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11370                break;
11371             }
11372          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11373             {
11374                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11375                break;
11376             }
11377          default:
11378               break;
11379       }
11380    }
11381
11382    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11383    {
11384       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11385       return RFAILED;
11386    }
11387    return ROK;
11388 }
11389 /*******************************************************************
11390 *
11391 * @brief processing of Gnb-DU config update
11392 *
11393 * @details
11394 *
11395 *    Function : procGnbDuUpdate
11396 *
11397 *    Functionality:
11398 *         - processing of Gnb-DU config update
11399 *
11400 * @params[in] F1AP_PDU_t *f1apMsg
11401 * @return ROK     - success
11402 *         RFAILED - failure
11403 *
11404 * ****************************************************************/
11405 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11406 {
11407    bool cellToBeDelete = false;
11408    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11409    uint16_t nrCellId;
11410    DuDb *duDb;
11411    CuCellCb *cellCb;
11412    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11413
11414    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11415    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11416    {
11417       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11418       {
11419          case ProtocolIE_ID_id_TransactionID:
11420             break;
11421          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11422             break;
11423          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11424             {
11425                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11426                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11427                   Served_Cells_To_Delete_List.list.array[0];
11428                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11429                cellToBeDelete = true;
11430                break;
11431             }
11432          case ProtocolIE_ID_id_gNB_DU_ID:
11433             break;
11434       }
11435    }
11436    if(BuildAndSendDUUpdateAck(duId) != ROK)
11437    {
11438       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11439       return RFAILED;
11440    }
11441 #if 0
11442    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11443     * commented this trigger for now */
11444
11445    if(cellToBeDelete == false)
11446    {
11447       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11448       if(BuildAndSendF1ResetReq() != ROK)
11449       {
11450          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11451          return RFAILED;
11452       }
11453    }
11454 #endif
11455    if(cellToBeDelete == true)
11456    {
11457       SEARCH_DU_DB(duIdx, duId, duDb);
11458       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11459       if(cellCb->numUe == 0)
11460       {
11461          memset(cellCb, 0, sizeof(CuCellCb));
11462          duDb->numCells--;
11463       }
11464       else
11465          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11466    }
11467    return ROK;
11468 }
11469
11470 /*******************************************************************
11471 *
11472 * @brief storing slice list in CU database
11473 *
11474 * @details
11475 *
11476 *    Function : buildSliceList
11477 *
11478 *    Functionality:
11479 *         - storing slice list in CU database
11480 *
11481 * @params[in] SliceSupportList_t *sliceSupportList
11482 * @return ROK     - success
11483 *         RFAILED - failure
11484 *
11485 * ****************************************************************/
11486 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11487 {
11488    uint8_t sliceListIdx = 0;
11489
11490    if(sliceSupportList)
11491    {
11492       if(sliceSupportList->list.array)
11493       {
11494          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11495          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11496          {
11497             if(sliceSupportList->list.array[sliceListIdx])
11498             {
11499                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11500                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11501                {
11502                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11503                    return RFAILED;
11504                }
11505                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11506                {
11507                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11508                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11509                }
11510                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11511                {
11512                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11513                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11514                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11515                }
11516             }
11517          }
11518       }
11519    }
11520    return ROK;
11521 }
11522
11523 /****************************************************************
11524  * @brief Function to process Srb Setup Mod List
11525  *
11526  * @details
11527  *
11528  *    Function : procSrbSetupModList
11529  *
11530  *    Functionality:
11531  *         - Function to process SRB Setup Mod List
11532  *
11533  * @params[in]
11534  * @return ROK     - success
11535  *         RFAILED - failure
11536  *
11537  * ****************************************************************/
11538 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11539 {
11540    uint8_t arrIdx = 0, srbIdx;
11541    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11542
11543    if(srbSetupList != NULLP)
11544    {
11545       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11546       {
11547          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11548          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11549          {
11550             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11551             {
11552                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11553                {
11554                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11555                   break;
11556                }
11557             }
11558          }
11559
11560       }
11561    }
11562    return ROK;
11563 }
11564
11565
11566 /****************************************************************
11567  * @brief Function to process Drb Setup Mod List
11568  *
11569  * @details
11570  *
11571  *    Function : procDrbSetupModList
11572  *
11573  *    Functionality:
11574  *         - Function to process DRB Setup Mod List
11575  *
11576  * @params[in]
11577  * @return ROK     - success
11578  *         RFAILED - failure
11579  *
11580  * ****************************************************************/
11581 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11582 {
11583    uint8_t arrIdx = 0, drbIdx;
11584    uint32_t teId = 0;
11585    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11586
11587    if(drbSetupList != NULLP)
11588    {
11589       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11590       {
11591          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11592          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11593          {
11594             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11595             {
11596                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11597                {
11598                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11599                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11600                   break;
11601                }
11602             }
11603
11604             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11605             {
11606             /* extracting teId */
11607             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11608             if(teId > 0)
11609             {
11610               if(addDrbTunnels(duId, teId)== ROK)
11611               {
11612                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11613               }
11614             }
11615             else
11616                return RFAILED;
11617             }
11618          }
11619       }
11620    }
11621    return ROK;
11622 }
11623
11624 /*******************************************************************
11625 *
11626 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11627 *
11628 * @details
11629 *
11630 *    Function : procServedCellPlmnList
11631 *
11632 *    Functionality:
11633 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11634 *         SNSSAI list
11635 *
11636 * @params[in] F1AP_PDU_t *f1apMsg
11637 * @return ROK     - success
11638 *         RFAILED - failure
11639 *
11640 * ****************************************************************/
11641 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11642 {
11643    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11644    ProtocolExtensionContainer_4624P3_t **ieExtend;
11645
11646    if(srvPlmn->list.array)
11647    {
11648       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11649       {
11650          if(srvPlmn->list.array[srvPlmnIdx])
11651          {
11652             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11653             if(*ieExtend)
11654             {
11655                if((*ieExtend)->list.array)
11656                {
11657                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11658                   {
11659                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11660                      {
11661                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11662                         {
11663                            case ProtocolIE_ID_id_TAISliceSupportList:
11664                               {
11665                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11666                                           extensionValue.choice.SliceSupportList) != ROK)
11667                                  {
11668                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11669                                     return RFAILED;
11670                                  }
11671                               }
11672                         }
11673                      }
11674                   }
11675                }
11676             }
11677          }
11678       }
11679    }
11680    return ROK;
11681 }
11682
11683 /****************************************************************
11684  * @brief Function to process Ue Context Modification Response
11685  *
11686  * @details
11687  *
11688  *    Function : procUeContextModificationResponse
11689  *
11690  *    Functionality:
11691  *         - Function to process Ue Context Modification Response
11692  *
11693  * @params[in]
11694  * @return ROK     - success
11695  *         RFAILED - failure
11696  *
11697  * ****************************************************************/
11698 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11699 {
11700    uint8_t idx=0, duIdx=0, countiX =1;
11701    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11702    DuDb *duDb = NULLP;
11703    CuUeCb *ueCb = NULLP;
11704    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11705
11706    SEARCH_DU_DB(duIdx, duId, duDb);
11707    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11708
11709    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11710    {
11711       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11712       {
11713           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11714              {
11715                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11716                 break;
11717              }
11718           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11719              {
11720                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11721                 ueCb = &duDb->ueCb[duUeF1apId-1];
11722                 break;
11723              }
11724           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11725              {
11726                 /* Adding Tunnels for successful DRB */
11727                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11728                 break;
11729
11730              }
11731           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11732              {
11733                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11734                 break;
11735              }
11736          case ProtocolIE_ID_id_DUtoCURRCInformation:
11737              {
11738                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11739                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11740                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11741                 {
11742                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11743                    return RFAILED;
11744                 }
11745                 break;
11746              }
11747
11748       }
11749    }
11750
11751    /* If UE is in handover and UE context is not yet created at target DU, then send
11752     * UE context setup request to target DU */
11753    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11754    {
11755       uint8_t ueIdx = 0;
11756       DuDb *tgtDuDb = NULLP;
11757       CuUeCb *ueCbInTgtDu = NULLP;
11758
11759       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11760       if(tgtDuDb)
11761       {
11762          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11763           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11764           * DB */
11765          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11766          {
11767             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11768             {
11769                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11770                break;
11771             }
11772          }
11773
11774          /* If UE context is not found in Target DU DU, send UE context setup
11775           * request */
11776          if(ueCbInTgtDu == NULLP)
11777          {
11778             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb)) != ROK)
11779             {
11780                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11781                return RFAILED;
11782             }
11783          }
11784       }
11785    }
11786 #ifdef NR_DRX
11787    if(countiX == 1)
11788    {
11789       countiX++;
11790       DU_LOG("\nPBORLA INFO  -->  F1AP: Sending UE Context Modification Request to MODIFY_UE");
11791       //BuildAndSendUeContextModificationReq(duId, ueCb, MODIFY_UE);
11792    }
11793 #endif
11794    return ROK;
11795 }
11796
11797 /*******************************************************************
11798 *
11799 * @brief processing of F1 setup request
11800 *
11801 * @details
11802 *
11803 *    Function : procF1SetupReq
11804 *
11805 *    Functionality:
11806 *         - processing of  F1 setup request
11807 *
11808 * @params[in] F1AP_PDU_t *f1apMsg
11809 * @return ROK     - success
11810 *         RFAILED - failure
11811 *
11812 * ****************************************************************/
11813 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11814 {
11815    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11816    uint32_t duId = 0;
11817    uint64_t nrCellId = 0;
11818    DuDb     *duDb = NULLP;
11819    CuCellCb *cellCb = NULLP;
11820    BIT_STRING_t nrcellIdentity;
11821    F1SetupRequest_t *f1SetupReq = NULLP;
11822    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11823    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11824
11825    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11826    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11827    {
11828       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11829       {
11830          case ProtocolIE_ID_id_gNB_DU_ID:
11831            {
11832               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11833               SEARCH_DU_DB(duIdx, duId, duDb);
11834               if(duDb == NULLP)
11835               {
11836                  duDb = &cuCb.duInfo[cuCb.numDu];
11837                  cuCb.numDu++;
11838               }
11839               memset(duDb, 0, sizeof(DuDb));
11840               duDb->duId = duId;
11841               *destDuId = duId;
11842               break;
11843            }
11844          case ProtocolIE_ID_id_gNB_DU_Name:
11845            {
11846               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11847               break;
11848            }
11849          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11850            {
11851                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11852                if(duServedCell->list.array)
11853                {
11854                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11855                   {
11856                      if(duServedCell->list.array[plmnidx])
11857                      {
11858                         switch(duServedCell->list.array[plmnidx]->id)
11859                         {
11860                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11861                            {
11862                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11863                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11864                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11865
11866                               bitStringToInt(&nrcellIdentity, &nrCellId);
11867                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11868                               if(cellCb == NULLP)
11869                               {
11870                                  cellCb = &duDb->cellCb[duDb->numCells];
11871                                  memset(cellCb, 0, sizeof(CuCellCb));
11872                                  cellCb->nrCellId = nrCellId;
11873                                  cellCb->cellStatus = CELL_ACTIVE;
11874                                  duDb->numCells++;
11875                               }
11876                            }
11877                         }
11878                      }
11879                   }
11880                }
11881            }
11882       }
11883    }
11884    if(ret == ROK)
11885    {
11886       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11887    }
11888    else
11889    {
11890        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11891    }
11892 }
11893
11894 /****************************************************************
11895 *
11896 * @brief processing of UE Context Release Complete
11897 *
11898 * @details
11899 *
11900 *    Function : procUeContextReleaseComplete
11901 *
11902 *    Functionality:
11903 *         - processing of UE Context Release Complete
11904 *
11905 * @params[in] F1AP_PDU_t *f1apMsg
11906 * @return ROK     - success
11907 *         RFAILED - failure
11908 *
11909 * ****************************************************************/
11910 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11911 {
11912    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0, drbIdx = 0;
11913    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11914    DuDb *duDb = NULLP;
11915    CuUeCb *ueCb = NULLP;
11916    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11917
11918    SEARCH_DU_DB(duIdx, duId, duDb);
11919    if(!duDb)
11920    {
11921       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11922       return;
11923    }
11924
11925    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11926    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11927    {
11928       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11929       {
11930          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11931             {
11932                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11933                break;
11934             }
11935          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11936             {
11937                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11938                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11939                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11940                {
11941                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11942                   {
11943                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11944                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11945                      {
11946                         for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11947                         {
11948                            deleteEgtpTunnel(duId, ueCb->drbList[drbIdx].dlUpTnlInfo.teId);
11949                         }
11950                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11951                         ueCb->cellCb->numUe--;
11952                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus == CELL_DELETION_IN_PROGRESS))
11953                         {
11954                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11955                            duDb->numCells--;
11956                         }
11957                         break;
11958                      }
11959                   }
11960                }
11961                memset(ueCb, 0, sizeof(CuUeCb));
11962                duDb->numUe--;
11963                break;
11964             }
11965       }
11966    }
11967 }
11968
11969 /*******************************************************************
11970  *
11971  * @brief Builds the Paging cell list
11972  *
11973  * @details
11974  *
11975  *    Function : BuildPagingCellList
11976  *
11977  *    Functionality: Build the paging cell list
11978  *
11979  * @params[in] PagingCell_list_t  *pagingCelllist,
11980  *
11981  * @return ROK     - success
11982  *         RFAILED - failure
11983  *
11984  * ****************************************************************/
11985 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11986 {
11987    uint8_t cellIdx =0;
11988    PagingCell_ItemIEs_t *pagingCellItemIes;
11989    PagingCell_Item_t *pagingCellItem;
11990
11991    pagingCelllist->list.count = numCells;
11992    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11993    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11994    if(pagingCelllist->list.array == NULLP)
11995    {
11996       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11997       return RFAILED;
11998    }
11999
12000    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12001    {
12002       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12003       if(pagingCelllist->list.array[cellIdx] == NULLP)
12004       {
12005          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
12006          return RFAILED;
12007       }
12008    }
12009
12010    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12011    {
12012       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12013       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
12014       pagingCellItemIes->criticality = Criticality_ignore;
12015       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
12016       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12017
12018       /* Fill NrCgi Information */
12019       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
12020    }
12021
12022    return ROK;
12023 }
12024
12025 /*******************************************************************
12026  *
12027  * @brief Deallocation of memory allocated in paging msg
12028  *
12029  * @details
12030  *
12031  *    Function :FreePagingMsg
12032  *
12033  *    Functionality: Deallocation of memory allocated in paging msg
12034  *
12035  * @params[in] F1AP_PDU_t *f1apMsg
12036  *
12037  * @return void
12038  *
12039  * ****************************************************************/
12040 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
12041 {
12042    uint8_t ieIdx, cellIdx;
12043    Paging_t   *paging;
12044    PagingCell_ItemIEs_t *pagingCellItemIes;
12045    PagingCell_Item_t *pagingCellItem;
12046    PagingCell_list_t  *pagingCelllist;
12047
12048    if(f1apMsg)
12049    {
12050       if(f1apMsg->choice.initiatingMessage)
12051       {
12052          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12053          if(paging->protocolIEs.list.array)
12054          {
12055             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
12056             {
12057                if(paging->protocolIEs.list.array[ieIdx])
12058                {
12059                   switch(paging->protocolIEs.list.array[ieIdx]->id)
12060                   {
12061                      case ProtocolIE_ID_id_UEIdentityIndexValue:
12062                      {
12063                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12064                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12065                         break;
12066                      }
12067
12068                      case ProtocolIE_ID_id_PagingIdentity:
12069                      {
12070                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
12071                         {
12072                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12073                            {
12074                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
12075                               {
12076                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12077                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12078                               }
12079                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
12080                                 sizeof(struct CNUEPagingIdentity));
12081                            }
12082                         }
12083                         break;
12084                      }
12085
12086                      case ProtocolIE_ID_id_PagingCell_List:
12087                      {
12088                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
12089                         if(pagingCelllist->list.array)
12090                         {
12091                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
12092                            {
12093                               if(pagingCelllist->list.array[cellIdx])
12094                               {
12095                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
12096                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
12097                                   {
12098                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
12099                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
12100                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
12101                                   }
12102                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
12103                               }
12104                            }
12105                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
12106                         }
12107                         break;
12108                      }
12109                   }
12110                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12111                }
12112             }
12113             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12114          }
12115          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12116       }
12117       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12118    }
12119 }
12120 /*******************************************************************
12121  *
12122  * @brief Builds and sends the paging message if UE is in idle mode
12123  *
12124  * @details
12125  *
12126  *    Function : BuildAndSendPagingMsg
12127  *
12128  *    Functionality: Builds and sends the paging message
12129  *
12130  * @params[in] uint32_t duId, uint8_t gsTmsi
12131  *
12132  * @return ROK     - success
12133  *         RFAILED - failure
12134  *
12135  * ****************************************************************/
12136 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
12137 {
12138    bool       memAllocFailed = false;
12139    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
12140    uint16_t   ueId = 0, duIdx = 0;
12141
12142    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
12143     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
12144    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
12145    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
12146
12147    F1AP_PDU_t *f1apMsg = NULLP;
12148    Paging_t   *paging = NULLP;
12149    DuDb       *duDb;
12150    asn_enc_rval_t         encRetVal;
12151
12152    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
12153
12154    SEARCH_DU_DB(duIdx, duId, duDb);
12155    if(duDb == NULLP)
12156    {
12157       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
12158       return ret;
12159    }
12160
12161    while(true)
12162    {
12163       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12164       if(f1apMsg == NULLP)
12165       {
12166          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
12167          break;
12168       }
12169
12170       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
12171
12172       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12173       if(f1apMsg->choice.initiatingMessage == NULLP)
12174       {
12175          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
12176          break;
12177       }
12178       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
12179       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12180       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
12181
12182       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
12183
12184       elementCnt = 5;
12185       paging->protocolIEs.list.count = elementCnt;
12186       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
12187
12188       /* Initialize the Paging Message members */
12189       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
12190       if(paging->protocolIEs.list.array == NULLP)
12191       {
12192          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
12193          break;
12194       }
12195
12196       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12197       {
12198          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
12199          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
12200          {
12201             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12202             memAllocFailed = true;
12203             break;
12204          }
12205       }
12206
12207       if(memAllocFailed == true)
12208       {
12209          break;
12210       }
12211
12212       /* UE Identity Index Value */
12213       ieIdx=0;
12214       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
12215       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12216       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
12217       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
12218       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
12219       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
12220             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
12221       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
12222       {
12223          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12224          break;
12225       }
12226
12227       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
12228       ueId = gsTmsi % 1024;
12229       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
12230
12231       /* Paging Identity */
12232       ieIdx++;
12233       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
12234       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12235       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
12236       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
12237                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
12238       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
12239             sizeof(struct CNUEPagingIdentity));
12240       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
12241       {
12242          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12243          break;
12244       }
12245
12246       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
12247                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
12248
12249       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
12250       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
12251             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
12252       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
12253       {
12254          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
12255          break;
12256       }
12257
12258       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
12259             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
12260
12261       /* Paging Drx */
12262       ieIdx++;
12263       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
12264       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12265       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
12266       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
12267
12268       /* Paging Priority */
12269       ieIdx++;
12270       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
12271       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12272       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
12273       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
12274
12275       /* Paging Cell List */
12276       ieIdx++;
12277       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
12278       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
12279       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
12280       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
12281       {
12282          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
12283          break;
12284       }
12285
12286       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12287
12288       /* Encode the UE Context Release Command type as APER */
12289       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12290       encBufSize = 0;
12291       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12292             encBuf);
12293
12294       /* Encode results */
12295       if(encRetVal.encoded == ENCODE_FAIL)
12296       {
12297          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
12298                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12299          break;
12300       }
12301       else
12302       {
12303          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
12304          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12305          {
12306             DU_LOG("%x",encBuf[ieIdx]);
12307          }
12308       }
12309
12310       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
12311       {
12312          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
12313          break;
12314       }
12315
12316       ret = ROK;
12317       break;
12318
12319    }
12320
12321    FreePagingMsg(f1apMsg);
12322    return ret;
12323 }
12324
12325 /*******************************************************************
12326  *
12327  * @brief Handles received F1AP message and sends back response
12328  *
12329  * @details
12330  *
12331  *    Function : F1APMsgHdlr
12332  *
12333  *    Functionality:
12334  *         - Decodes received F1AP control message
12335  *         - Prepares response message, encodes and sends to SCTP
12336  *
12337  * @params[in]
12338  * @return ROK     - success
12339  *         RFAILED - failure
12340  *
12341  * ****************************************************************/
12342 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12343 {
12344    int i;
12345    char *recvBuf;
12346    MsgLen copyCnt;
12347    MsgLen recvBufLen;
12348    F1AP_PDU_t *f1apMsg = NULLP;
12349    asn_dec_rval_t rval; /* Decoder return value */
12350    F1AP_PDU_t f1apasnmsg ;
12351
12352    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12353    ODU_PRINT_MSG(mBuf, 0,0);
12354
12355    /* Copy mBuf into char array to decode it */
12356    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12357    CU_ALLOC(recvBuf, (Size)recvBufLen);
12358
12359    if(recvBuf == NULLP)
12360    {
12361       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12362       return;
12363    }
12364    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12365    {
12366       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12367       return;
12368    }
12369
12370    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12371    for(i=0; i< recvBufLen; i++)
12372    {
12373       DU_LOG("%x",recvBuf[i]);
12374    }
12375
12376    /* Decoding flat buffer into F1AP messsage */
12377    f1apMsg = &f1apasnmsg;
12378    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12379
12380    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12381    CU_FREE(recvBuf, (Size)recvBufLen);
12382
12383    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12384    {
12385       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12386       return;
12387    }
12388    DU_LOG("\n");
12389    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12390
12391    switch(f1apMsg->present)
12392    {
12393       case F1AP_PDU_PR_initiatingMessage:
12394          {
12395             switch(f1apMsg->choice.initiatingMessage->value.present)
12396             {
12397                case InitiatingMessage__value_PR_Reset:
12398                   {
12399                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12400                      BuildAndSendF1ResetAck();
12401                      break;
12402                   }
12403
12404                case InitiatingMessage__value_PR_F1SetupRequest:
12405                   {
12406                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12407                      procF1SetupReq(duId, f1apMsg);
12408                      break;
12409                   }
12410
12411                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12412                   {
12413                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12414                      procGnbDuUpdate(*duId, f1apMsg);
12415                      break;
12416                   }
12417                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12418                   {
12419                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12420                      procInitULRRCMsg(*duId, f1apMsg);
12421                      break;
12422                   }
12423                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12424                   {
12425                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12426                      procUlRrcMsg(*duId, f1apMsg);
12427                      break;
12428                   }
12429
12430                case InitiatingMessage__value_PR_RRCDeliveryReport:
12431                   {
12432                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12433                      break;
12434                   }
12435                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12436                   {
12437                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12438                      procUeContextReleaseReq(*duId, f1apMsg);
12439                      break;
12440                   }
12441                default:
12442                   {
12443                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12444                            f1apMsg->choice.initiatingMessage->value.present);
12445                      return;
12446                   }
12447             }/* End of switch(initiatingMessage) */
12448             break;
12449          }
12450
12451       case F1AP_PDU_PR_successfulOutcome:
12452          {
12453             switch(f1apMsg->choice.successfulOutcome->value.present)
12454             {
12455                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12456                   {
12457                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12458                      break;
12459                   }
12460                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12461                   {
12462                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12463                      procUeContextSetupResponse(*duId, f1apMsg);
12464                      break;
12465                   }
12466                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12467                   {
12468                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12469                      procUeContextModificationResponse(*duId, f1apMsg);
12470                      break;
12471                   }
12472                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12473                   {
12474                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12475                       procUeContextReleaseComplete(*duId, f1apMsg);
12476                       break;
12477                   }
12478                default:
12479                   {
12480                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12481                            f1apMsg->choice.successfulOutcome->value.present);
12482                      return;
12483                   }
12484             }/* End of switch(successfulOutcome) */
12485             break;
12486          }
12487       default:
12488          {
12489             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12490             return;
12491          }
12492    }/* End of switch(f1apMsg->present) */
12493
12494 } /* End of F1APMsgHdlr */
12495
12496 /**********************************************************************
12497   End of file
12498  **********************************************************************/