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