src/du_app/du_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 "ckw.h"
  22 #include "ckw.x"
  23 #include "kwu.h"
  24 #include "kwu.x"
  25 #include "lkw.h"
  26 #include "lrg.h"
  27 #include "legtp.h"
  28 #include "lkw.x"
  29 #include "lrg.x"
  30 #include "F1AP-PDU.h"
  31 #include "du_app_mac_inf.h"
  32 #include "du_cfg.h"
  33 #include "du_app_rlc_inf.h"
  34 #include "du_mgr_main.h"
  35 #include "du_mgr.h"
  36 #include "du_utils.h"
  37 #include "du_ue_mgr.h"
  38 #include "RAT-Type.h"
  39 #include "FeatureSetUplinkPerCC.h"
  40 #include "FeatureSetDownlinkPerCC.h"
  41 #include "FeatureSets.h"
  42 #include "UE-NR-Capability.h"
  43 #include "UE-CapabilityRAT-Container.h"
  44 #include "UE-CapabilityRAT-ContainerListRRC.h"
  45 #include "GNB-DU-System-Information.h"
  46 #include "CellGroupConfigRrc.h"
  47 #include "MAC-CellGroupConfig.h"
  48 #include "SchedulingRequestConfig.h"
  49 #include "SchedulingRequestToAddMod.h"
  50 #include "BSR-Config.h"
  51 #include "TAG-Config.h"
  52 #include "TAG.h"
  53 #include "PHR-Config.h"
  54 #include "RLC-Config.h"
  55 #include "UL-AM-RLC.h"
  56 #include "DL-AM-RLC.h"
  57 #include "LogicalChannelConfig.h"
  58 #include "RLC-BearerConfig.h"
  59 #include "PhysicalCellGroupConfig.h"
  60 #include "SpCellConfig.h"
  61 #include "TDD-UL-DL-ConfigDedicated.h"
  62 #include "ServingCellConfig.h"
  63 #include "ControlResourceSet.h"
  64 #include "SearchSpace.h"
  65 #include "PDCCH-Config.h"
  66 #include "PDSCH-TimeDomainResourceAllocation.h"
  67 #include "PDSCH-TimeDomainResourceAllocationList.h"
  68 #include "PDSCH-CodeBlockGroupTransmission.h"
  69 #include "PDSCH-ServingCellConfig.h"
  70 #include "DMRS-DownlinkConfig.h"
  71 #include "PDSCH-Config.h"
  72 #include "BWP-DownlinkDedicated.h"
  73 #include "BWP-Downlink.h"
  74 #include "PUSCH-TimeDomainResourceAllocation.h"
  75 #include "PUSCH-TimeDomainResourceAllocationList.h"
  76 #include "DMRS-UplinkConfig.h"
  77 #include "PUSCH-Config.h"
  78 #include "SRS-ResourceId.h"
  79 #include "SRS-Resource.h"
  80 #include "SRS-ResourceSet.h"
  81 #include "SRS-Config.h"
  82 #include "BWP-UplinkDedicated.h"
  83 #include "PUSCH-ServingCellConfig.h"
  84 #include "UplinkConfig.h"
  85 #include "DUtoCURRCContainer.h"
  86 #include "GBR-QoSFlowInformation.h"
  87 #include "QoSFlowLevelQoSParameters.h"
  88 #include "PUCCH-Config.h"
  89 #include "PUCCH-ResourceSet.h"
  90 #include "PUCCH-Resource.h"
  91 #include "PUCCH-PowerControl.h"
  92 #include "P0-PUCCH.h"
  93 #include "PUCCH-PathlossReferenceRS.h"
  94 #include "PUCCH-format0.h"
  95 #include "PUCCH-format1.h"
  96 #include "PUCCH-format2.h"
  97 #include "PUCCH-format3.h"
  98 #include "PUCCH-format4.h"
  99 #include "PUCCH-FormatConfig.h"
 100 #include "SchedulingRequestResourceConfig.h"
 101 #include<ProtocolIE-Field.h>
 102 #include "ProtocolExtensionField.h"
 103 #include "odu_common_codec.h"
 104 #include "du_mgr.h"
 105 #include "du_cell_mgr.h"
 106 #include "du_f1ap_msg_hdl.h"
 107 #include "DRBs-Setup-Item.h"
 108 #include "DLUPTNLInformation-ToBeSetup-List.h"
 109 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 110 #include "UPTransportLayerInformation.h"
 111 #include "GTPTunnel.h"
 112 #include "SupportedSULFreqBandItem.h"
 113 #include "du_e2ap_msg_hdl.h"
 114 #include "du_f1ap_conversions.h"
 115 #include "CNUEPagingIdentity.h"
 116 #include "PCCH-Config.h"
 117 #include "SCS-SpecificCarrier.h"
 118 #include "FrequencyInfoDL.h"
 119 #include "DownlinkConfigCommon.h"
 120 #include "FrequencyInfoUL.h"
 121 #include "UplinkConfigCommon.h"
 122 #include "TDD-UL-DL-ConfigCommon.h"
 123 #include "RACH-ConfigDedicated.h"
 124 #include "CFRA-SSB-Resource.h"
 125 #include "BWP-UplinkCommon.h"
 126 #include "ReconfigurationWithSync.h"
 127 #include "du_sys_info_hdl.h"
 128
 129 #ifdef O1_ENABLE
 130 #include "CmInterface.h"
 131 extern StartupConfig g_cfg;
 132 #endif
 133
 134 DuCfgParams duCfgParam;
 135
 136 /******************************************************************
 137  *
 138  * @brief Function to fetch lcId based on DRB Id
 139  *
 140  * @details
 141  *
 142  *    Function : fetchLcId
 143  *
 144  *    @params[in] drbId
 145  *
 146  *    Functionality: Function to fetch lcId based on DRB Id
 147  *
 148  * Returns: lcId - SUCCESS
 149  *          RFAILED - FAILURE
 150  *****************************************************************/
 151
 152 uint8_t fetchLcId(uint8_t drbId)
 153 {
 154    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 155
 156    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 157    {
 158       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 159       {
 160          if(duCb.actvCellLst[cellIdx] != NULLP)
 161          {
 162             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 163             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 164             {
 165                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 166                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 167                {
 168                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 169                   return lcId;
 170                }
 171             }
 172          }
 173       }
 174    }
 175    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 176    return RFAILED;
 177 }
 178
 179 /*******************************************************************
 180 *
 181 * @brief Adding F1AP pdu to reserved pdu list
 182 *
 183 * @details
 184 *
 185 *    Function : addToReservedF1apPduList
 186 *
 187 *    Functionality: Adding F1AP pdu to reserved pdu list.
 188 *     These pdu are awaiting aknowledgment from CU
 189 *
 190 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 191 *
 192 * @return ROK - success
 193 *         RFAILED - failure
 194 *
 195 * ****************************************************************/
 196 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 197 {
 198    CmLList         *node = NULLP;
 199    ReservedF1apPduInfo *pduInfo = NULLP;
 200    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 201    if(pduInfo)
 202    {
 203       DU_ALLOC(node, sizeof(CmLList));
 204       if(node)
 205       {
 206          pduInfo->transId = transId;
 207          pduInfo->f1apMsg = (void*) f1apPdu;
 208
 209          node->node = (PTR)pduInfo;
 210          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 211       }
 212    }
 213 }
 214
 215 /*******************************************************************
 216 *
 217 * @brief searching for F1AP pdu from ReservedF1apPduList
 218 *
 219 * @details
 220 *
 221 *    Function : searchFromReservedF1apPduList
 222 *
 223 *    Functionality: searching for F1AP pdu information
 224 *
 225 * @params[in] uint8_t transId
 226 *
 227 * @return pointer to F1AP_PDU_t
 228 *
 229 * ****************************************************************/
 230
 231 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 232 {
 233    CmLList         *node;
 234    ReservedF1apPduInfo *f1apPdu;
 235    if(duCb.reservedF1apPduList.count)
 236    {
 237       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 238       while(node)
 239       {
 240          f1apPdu = (ReservedF1apPduInfo*)node->node;
 241          if(f1apPdu->transId == transId)
 242          {
 243             return node;
 244          }
 245          node = node->next;
 246       }
 247    }
 248    return NULL;
 249 }
 250
 251 /*******************************************************************
 252 *
 253 * @brief deleting F1AP pdu information from ReservedF1apPduList
 254 *
 255 * @details
 256 *
 257 *    Function : deleteFromReservedF1apPduList
 258 *
 259 *    Functionality: deleting pdu information from ReservedF1apPduList
 260 *
 261 * @params[in] CmLList *node
 262 *
 263 * @return void
 264 *
 265 * ****************************************************************/
 266
 267 void deleteFromReservedF1apPduList(CmLList *node)
 268 {
 269    ReservedF1apPduInfo *f1apPdu;
 270
 271    if(node != NULL)
 272    {
 273       f1apPdu = (ReservedF1apPduInfo *)node->node;
 274       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 275       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 276       DU_FREE(node, sizeof(CmLList));
 277       node = NULL;
 278    }
 279 }
 280
 281 /*******************************************************************
 282  *
 283  * @brief Builds Uplink Info for NR
 284  *
 285  * @details
 286  *
 287  *    Function : BuildULNRInfo
 288  *
 289  *    Functionality: Building NR Uplink Info
 290  *
 291  * @params[in] NRFreqInfo_t *ulnrfreq
 292  * @return ROK     - success
 293  *         RFAILED - failure
 294  *
 295  * ****************************************************************/
 296 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 297 {
 298    uint8_t idx=0;
 299    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 300                        fdd.ulNrFreqInfo.nrArfcn;
 301    ulnrfreq->freqBandListNr.list.count = 1;
 302    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 303    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 304    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 305    {
 306       return RFAILED;
 307    }
 308    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 309    {
 310       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 311       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 312       {
 313          return RFAILED;
 314       }
 315    }
 316    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 317                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 318                                                                  freqBand[0].nrFreqBand;
 319    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 320    return ROK;
 321 }
 322 /*******************************************************************
 323  *
 324  * @brief Builds Downlink NR Info
 325  *
 326  * @details
 327  *
 328  *    Function : BuildDLNRInfo
 329  *
 330  *    Functionality: Building Downlink NR Info
 331  *
 332  * @params[in] NRFreqInfo_t *dlnrfreq
 333  * @return ROK     - success
 334  *         RFAILED - failure
 335  *
 336  * ****************************************************************/
 337 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 338 {
 339    uint8_t idx=0;
 340    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 341                        fdd.dlNrFreqInfo.nrArfcn;
 342    dlnrfreq->freqBandListNr.list.count = 1;
 343    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 344    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 345    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 346    {
 347       return RFAILED;
 348    }
 349    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 350    {
 351       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 352       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 353       {
 354          return RFAILED;
 355       }
 356    }
 357    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 358                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 359                                                                  freqBand[0].nrFreqBand;
 360    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 361
 362    return ROK;
 363 }
 364
 365 /*******************************************************************
 366  *
 367  * @brief Builds Nrcgi
 368  *
 369  * @details
 370  *
 371  *    Function : BuildNrcgi
 372  *
 373  *    Functionality: Building the PLMN ID and NR Cell id
 374  *
 375  * @params[in] NRCGI_t *nrcgi
 376  * @return ROK     - success
 377  *         RFAILED - failure
 378  *
 379  * ****************************************************************/
 380 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 381 {
 382    uint8_t ret;
 383    uint8_t byteSize = 5;
 384    /* Allocate Buffer Memory */
 385    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 386    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 387    if(nrcgi->pLMN_Identity.buf == NULLP)
 388    {
 389       return RFAILED;
 390    }
 391    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 392          nrcgi->pLMN_Identity.buf); // Building PLMN function
 393    if(ret != ROK)
 394    {
 395       return RFAILED;
 396    }
 397    /*nrCellIdentity*/
 398    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 399    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 400    if(nrcgi->nRCellIdentity.buf == NULLP)
 401    {
 402       return RFAILED;
 403    }
 404    fillBitString(&nrcgi->nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
 405
 406    return ROK;
 407 }
 408 /*******************************************************************
 409  *
 410  * @brief Builds FiveGStac
 411  *
 412  * @details
 413  *
 414  *    Function : BuildFiveGSTac
 415  *
 416  *    Functionality: Building the FiveGSTac
 417  *
 418  * @params[in] OCTET_STRING_t *fivegsTac
 419  * @return ROK     - success
 420  *         RFAILED - failure
 421  *
 422  * ****************************************************************/
 423 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 424 {
 425    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 426    if(servcell->fiveGS_TAC == NULLP)
 427    {
 428       return RFAILED;
 429    }
 430    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 431    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 432          sizeof(servcell->fiveGS_TAC->size));
 433    if(servcell->fiveGS_TAC->buf == NULLP)
 434    {
 435       return RFAILED;
 436    }
 437    servcell->fiveGS_TAC->buf[0] = 0;
 438    servcell->fiveGS_TAC->buf[1] = 0;
 439    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 440    return ROK;
 441 }
 442
 443 /*******************************************************************
 444  *
 445  * @brief fill nr frequency information
 446  *
 447  * @details
 448  *
 449  *    Function : fillNrTddInfo
 450  *
 451  *    Functionality: fill nr frequency information
 452  *
 453  * @params[in] NRFreqInfo_t freqInfo
 454  * @return ROK     - success
 455  *         RFAILED - failure
 456  *
 457  * ****************************************************************/
 458 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 459 {
 460    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 461    NRFreqInfo_t *freqInfo = NULLP;
 462
 463    if(tddInfo == NULLP)
 464    {
 465       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 466       return RFAILED;
 467    }
 468
 469    freqInfo = &tddInfo->nRFreqInfo;
 470    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 471
 472    freqInfo->freqBandListNr.list.count = elementCnt;
 473    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 474    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 475    if(!freqInfo->freqBandListNr.list.array)
 476    {
 477       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 478       return RFAILED;
 479    }
 480
 481    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 482    {
 483       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 484       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 485       {
 486          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 487          return RFAILED;
 488       }
 489
 490       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 491       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 492       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 493       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 494       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 495
 496       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 497             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 498       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 499       {
 500          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 501          return RFAILED;
 502       }
 503
 504       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 505       {
 506          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 507                sizeof(SupportedSULFreqBandItem_t));
 508          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 509          {
 510             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 511             return RFAILED;
 512          }
 513
 514          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 515          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 516       }
 517    }
 518
 519    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 520    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 521
 522    return ROK;
 523 }
 524
 525 /*******************************************************************
 526  *
 527  * @brief Builds NR Mode
 528  *
 529  * @details
 530  *
 531  *    Function : BuildNrMode
 532  *
 533  *    Functionality: Building the NR Mode
 534  *
 535  * @params[in] NR_Mode_Info_t *fdd
 536  * @return ROK     - success
 537  *         RFAILED - failure
 538  *
 539  * ****************************************************************/
 540 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 541 {
 542    uint8_t BuildDLNRInforet=0;
 543    uint8_t BuildULNRInforet=0;
 544
 545 #ifdef NR_TDD
 546    mode->present = NR_Mode_Info_PR_tDD;
 547 #else
 548    mode->present = NR_Mode_Info_PR_fDD;
 549 #endif
 550
 551    if(mode->present == NR_Mode_Info_PR_fDD)
 552    {
 553       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 554       if(mode->choice.fDD == NULLP)
 555       {
 556          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 557          return RFAILED;
 558       }
 559       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 560       if(BuildULNRInforet != ROK)
 561       {
 562          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 563          return RFAILED;
 564       }
 565       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 566       if(BuildDLNRInforet != ROK)
 567       {
 568          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 569          return RFAILED;
 570       }
 571       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 572                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 573                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 574       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 575                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 576                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 577       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 578                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 579                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 580       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 581                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 582                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 583    }
 584    else if(mode->present == NR_Mode_Info_PR_tDD)
 585    {
 586       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 587       if(mode->choice.tDD == NULLP)
 588       {
 589          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 590          return RFAILED;
 591       }
 592
 593       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 594       {
 595          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 596          return RFAILED;
 597       }
 598
 599    }
 600
 601    return ROK;
 602 }
 603 /*******************************************************************
 604  *
 605  * @brief Builds IE Extensions for Served PLMNs
 606  *
 607  * @details
 608  *
 609  *    Function : BuildExtensions
 610  *
 611  *    Functionality: Building the IE Extensions
 612  *
 613  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 614  * @return ROK     - success
 615  *         RFAILED - failure
 616  *
 617  * ****************************************************************/
 618 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 619 {
 620    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 621    uint8_t elementCnt=0, extensionCnt=0;
 622
 623    extensionCnt=IE_EXTENSION_LIST_COUNT;
 624    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 625    if((*ieExtend) == NULLP)
 626    {
 627       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 628       return RFAILED;
 629    }
 630    (*ieExtend)->list.count = extensionCnt;
 631    (*ieExtend)->list.size = \
 632                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 633    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 634    if((*ieExtend)->list.array == NULLP)
 635    {
 636       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 637       return RFAILED;
 638    }
 639    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 640    {
 641       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 642             sizeof(ServedPLMNs_ItemExtIEs_t));
 643       if((*ieExtend)->list.array[plmnidx] == NULLP)
 644       {
 645          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 646          return RFAILED;
 647       }
 648    }
 649
 650    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 651    idx = 0;
 652    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 653    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 654    (*ieExtend)->list.array[idx]->extensionValue.present = \
 655    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 656    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 657       list.count = elementCnt;
 658    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 659       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 660       list.count * sizeof(SliceSupportItem_t *);
 661
 662    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 663          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 664    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 665          list.array == NULLP)
 666    {
 667       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 668       return RFAILED;
 669    }
 670
 671    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 672    {
 673       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 674             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 675       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 676             list.array[sliceLstIdx] == NULLP)
 677       {
 678          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 679          return RFAILED;
 680       }
 681       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 682          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
 683       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 684             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 685             extensionValue.choice.SliceSupportList.\
 686             list.array[sliceLstIdx]->sNSSAI.sST.size);
 687       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 688             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
 689       {
 690          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 691          return RFAILED;
 692       }
 693       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 694          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 695          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 696
 697       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 698             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 699       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 700             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 701       {
 702          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 703          return RFAILED;
 704       }
 705       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 706          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 707       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 708             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 709             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 710       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 711             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 712       {
 713          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 714          return RFAILED;
 715       }
 716       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 717       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 718       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 719       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 720    }
 721    return ROK;
 722 }
 723 /*******************************************************************
 724  *
 725  * @brief Builds Served PLMN
 726  *
 727  * @details
 728  *
 729  *    Function : BuildServedPlmn
 730  *
 731  *    Functionality: Building the Served PLMN
 732  *
 733  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 734  * @return ROK     - success
 735  *         RFAILED - failure
 736  *
 737  * ****************************************************************/
 738 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 739 {
 740    uint8_t  plmnidx;
 741    uint8_t  servPlmnCnt=1;
 742    uint8_t buildPlmnIdret=0;
 743    uint8_t BuildExtensionsret=0;
 744    srvplmn->list.count = servPlmnCnt;
 745    srvplmn->list.size = \
 746                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 747    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 748    if(srvplmn->list.array == NULLP)
 749    {
 750       return RFAILED;
 751    }
 752    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 753    {
 754       DU_ALLOC(srvplmn->list.array[plmnidx],\
 755             sizeof(ServedPLMNs_Item_t));
 756       if(srvplmn->list.array[plmnidx] == NULLP)
 757       {
 758          return RFAILED;
 759       }
 760    }
 761    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 762    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 763    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 764          srvplmn->list.array[0]->pLMN_Identity.buf);
 765    if(buildPlmnIdret!= ROK)
 766    {
 767       return RFAILED;
 768    }
 769    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 770    if(BuildExtensionsret!= ROK)
 771    {
 772       return RFAILED;
 773    }
 774    return ROK;
 775 }
 776 /*******************************************************************
 777  *
 778  * @brief Builds Served Cell List
 779  *
 780  * @details
 781  *
 782  *    Function : BuildServedCellList
 783  *
 784  *    Functionality: Building Served Cell List
 785  *
 786  * @params[in] PLMNID plmn
 787  * @return ROK     - success
 788  *         RFAILED - failure
 789  *
 790  * ****************************************************************/
 791
 792 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 793 {
 794    uint8_t  BuildNrcgiret=0;
 795    uint8_t  BuildFiveGSTacret=0;
 796    uint8_t  BuildServedPlmnret=0;
 797    uint8_t  BuildNrModeret=0;
 798    uint8_t  idx;
 799    uint8_t  plmnidx;
 800    uint8_t  plmnCnt=1;
 801    GNB_DU_Served_Cells_Item_t *srvCellItem;
 802    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 803    duServedCell->list.count = plmnCnt;
 804
 805    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 806    if(duServedCell->list.array == NULLP)
 807    {
 808       return RFAILED;
 809    }
 810    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 811    {
 812       DU_ALLOC(duServedCell->list.array[plmnidx],\
 813             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 814       if(duServedCell->list.array[plmnidx] == NULLP)
 815       {
 816          return RFAILED;
 817       }
 818    }
 819    idx = 0;
 820    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 821    duServedCell->list.array[idx]->criticality = Criticality_reject;
 822    duServedCell->list.array[idx]->value.present = \
 823                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 824    srvCellItem = \
 825                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 826    /*nRCGI*/
 827    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 828    if(BuildNrcgiret != ROK)
 829    {
 830       return RFAILED;
 831    }
 832    /*nRPCI*/
 833    srvCellItem->served_Cell_Information.nRPCI = \
 834                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 835
 836    /*fiveGS_TAC*/
 837    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 838    if(BuildFiveGSTacret != ROK)
 839    {
 840       return RFAILED;
 841    }
 842    /*Served PLMNs*/
 843    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 844    if(BuildServedPlmnret !=ROK)
 845    {
 846       return RFAILED;
 847    }
 848    /*nR Mode Info with FDD*/
 849    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 850    if(BuildNrModeret != ROK)
 851    {
 852       return RFAILED;
 853    }
 854    /*Measurement timing Config*/
 855    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 856       size = sizeof(uint8_t);
 857    DU_ALLOC(srvCellItem->served_Cell_Information.\
 858          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 859    if(srvCellItem->served_Cell_Information.\
 860          measurementTimingConfiguration.buf == NULLP)
 861    {
 862       return RFAILED;
 863    }
 864    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 865                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 866
 867    /* GNB DU System Information */
 868    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 869          sizeof(GNB_DU_System_Information_t));
 870    if(!srvCellItem->gNB_DU_System_Information)
 871    {
 872       return RFAILED;
 873    }
 874    /* MIB */
 875    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
 876    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 877          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 878    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 879    {
 880       return RFAILED;
 881    }
 882    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
 883                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
 884
 885    /* SIB1 */
 886    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 887                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 888
 889    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 890          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 891    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 892    {
 893       return RFAILED;
 894    }
 895    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 896    {
 897       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 898                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 899    }
 900    return ROK;
 901 }
 902 /*******************************************************************
 903  *
 904  * @brief Builds RRC Version
 905  *
 906  * @details
 907  *
 908  *    Function : BuildRrcVer
 909  *
 910  *    Functionality: Building RRC Version
 911  *
 912  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 913  * @return ROK     - success
 914  *         RFAILED - failure
 915  *
 916  * ****************************************************************/
 917 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 918 {
 919    uint8_t rrcExt;
 920    uint8_t rrcLatest;
 921    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 922    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 923    if(rrcVer->latest_RRC_Version.buf == NULLP)
 924    {
 925       return RFAILED;
 926    }
 927    rrcVer->latest_RRC_Version.buf[0] = 0;
 928    rrcVer->latest_RRC_Version.bits_unused = 5;
 929    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 930    if(rrcVer->iE_Extensions == NULLP)
 931    {
 932       return RFAILED;
 933    }
 934    rrcVer->iE_Extensions->list.count = 1;
 935    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 936    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 937    if(rrcVer->iE_Extensions->list.array == NULLP)
 938    {
 939       return RFAILED;
 940    }
 941    rrcExt = 0;
 942    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 943          sizeof(RRC_Version_ExtIEs_t));
 944    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 945    {
 946       return RFAILED;
 947    }
 948    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 949                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 950    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 951    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 952                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 953    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 954       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 955    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 956          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 957          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 958    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 959          .Latest_RRC_Version_Enhanced.buf == NULLP)
 960    {
 961       return RFAILED;
 962    }
 963    rrcLatest = 0;
 964    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 965       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 966    rrcLatest++;
 967    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 968       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 969    rrcLatest++;
 970    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 971       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 972    return ROK;
 973 }
 974 /*******************************************************************
 975  *
 976  * @brief Sends F1 msg over SCTP
 977  *
 978  * @details
 979  *
 980  *    Function : sendF1APMsg
 981  *
 982  *    Functionality: Sends F1 msg over SCTP
 983  *
 984  * @params[in] Region region
 985  *             Pool pool
 986  * @return ROK     - success
 987  *         RFAILED - failure
 988  *
 989  * ****************************************************************/
 990 uint8_t sendF1APMsg()
 991 {
 992    Buffer *mBuf = NULLP;
 993
 994    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
 995    {
 996       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 997       {
 998             ODU_PRINT_MSG(mBuf, 0,0);
 999
1000             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1001             {
1002                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1003                ODU_PUT_MSG_BUF(mBuf);
1004                return RFAILED;
1005             }
1006       }
1007       else
1008       {
1009          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1010          ODU_PUT_MSG_BUF(mBuf);
1011          return RFAILED;
1012       }
1013       ODU_PUT_MSG_BUF(mBuf);
1014    }
1015    else
1016    {
1017       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1018       return RFAILED;
1019    }
1020    return ROK;
1021 } /* sendF1APMsg */
1022
1023 /*******************************************************************
1024  *
1025  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1026  *
1027  * @details
1028  *
1029  *    Function :  FreeRrcVer
1030  *
1031  *    Functionality: deallocating the memory of function BuildRrcVer
1032  *
1033  * @params[in] RRC_Version_t *rrcVer
1034  *
1035  * @return void
1036  *
1037  *****************************************************************/
1038 void FreeRrcVer(RRC_Version_t *rrcVer)
1039 {
1040    if(rrcVer->latest_RRC_Version.buf != NULLP)
1041    {
1042       if(rrcVer->iE_Extensions != NULLP)
1043       {
1044          if(rrcVer->iE_Extensions->list.array != NULLP)
1045          {
1046             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1047             {
1048                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1049                      != NULLP)
1050                {
1051                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1052                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1053                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1054                }
1055                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1056             }
1057             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1058          }
1059          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1060       }
1061       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1062    }
1063 }
1064
1065 /*******************************************************************
1066  *
1067  * @brief Deallocating memory of TDD NrFreqInfo
1068  *
1069  * @details
1070  *
1071  *    Function : freeTddNrFreqInfo
1072  *
1073  *    Functionality: freeTddNrFreqInfo
1074  *
1075  * @params[in]  F1AP_PDU_t *f1apDuCfg
1076  *
1077  * @return ROK     - void
1078  *
1079  * ****************************************************************/
1080 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1081 {
1082    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1083
1084    if(freqInfo->freqBandListNr.list.array)
1085    {
1086       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1087       {
1088          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1089          {
1090             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1091             {
1092                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1093                {
1094                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1095                         sizeof(SupportedSULFreqBandItem_t));
1096                }
1097                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1098                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1099
1100             }
1101             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1102          }
1103       }
1104       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1105    }
1106 }
1107
1108 /*******************************************************************
1109  *
1110  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1111  *
1112  * @details
1113  *
1114  *    Function : freeFddNrFreqInfo
1115  *
1116  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1117  *
1118  * @params[in]
1119  *
1120  * @return ROK     - void
1121  *
1122  * ****************************************************************/
1123 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1124 {
1125    uint8_t arrIdx =0;
1126
1127    if(fDD != NULLP)
1128    {
1129       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1130       {
1131          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1132                array[arrIdx], sizeof(FreqBandNrItem_t));
1133          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1134                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1135       }
1136
1137       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1138       {
1139          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1140                array[arrIdx], sizeof(FreqBandNrItem_t));
1141          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1142                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1143       }
1144       DU_FREE(fDD,sizeof(FDD_Info_t));
1145    }
1146 }
1147
1148 /*******************************************************************
1149  *
1150  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1151  *
1152  * @details
1153  *
1154  *    Function :  FreeServedCellList
1155  *
1156  *    Functionality:  deallocating the memory of function BuildServedCellList
1157
1158  *
1159  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1160  *
1161  * @return void
1162  *
1163  * ****************************************************************/
1164 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1165 {
1166    uint8_t   plmnCnt=MAX_PLMN;
1167    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1168    uint8_t  plmnIdx=0, sliceIdx=0;
1169    GNB_DU_Served_Cells_Item_t *srvCellItem;
1170    ServedPLMNs_Item_t  *servedPlmnItem;
1171    SliceSupportItem_t  *sliceSupportItem;
1172
1173    if(duServedCell->list.array!=NULLP)
1174    {
1175       if(duServedCell->list.array[0]!=NULLP)
1176       {
1177          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1178
1179          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1180                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1181          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1182                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1183
1184          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1185          {
1186             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1187                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1188             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1189          }
1190
1191          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1192          {
1193             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1194             {
1195                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1196                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1197
1198                if(servedPlmnItem->iE_Extensions != NULLP)
1199                {
1200                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1201                   {
1202                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1203                      {
1204                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1205                               SliceSupportList.list.array != NULLP)
1206                         {
1207                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1208                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1209                            {
1210                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1211                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1212                               {
1213                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1214                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1215
1216                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1217
1218                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1219                                  {
1220                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1221                                           sliceSupportItem->sNSSAI.sD->size);
1222                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1223                                  }
1224
1225                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1226                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1227                               }
1228                            }
1229                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1230                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1231                                  extensionValue.choice.SliceSupportList.list.size);
1232                         }
1233                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1234                               sizeof(ServedPLMNs_ItemExtIEs_t));
1235                      }
1236                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1237                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1238                   }
1239                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1240                }
1241                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1242                      sizeof(ServedPLMNs_Item_t));
1243             }
1244             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1245                   sizeof(ServedPLMNs_Item_t *));
1246          }
1247
1248          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1249          {
1250             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1251          }
1252          else
1253          {
1254             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1255             {
1256                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1257                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1258             }
1259          }
1260
1261          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1262                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1263
1264          if(srvCellItem->gNB_DU_System_Information != NULLP)
1265          {
1266             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1267             {
1268                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1269                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1270             }
1271
1272             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1273             {
1274                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1275                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1276             }
1277
1278             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1279          }
1280
1281          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1282       }
1283       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1284    }
1285 }
1286
1287 /*******************************************************************
1288  *
1289  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1290  *
1291  * @details
1292  *
1293  *    Function :  FreeF1SetupReq
1294  *
1295  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1296  *
1297  * @params[in] F1AP_PDU_t *f1apMsg
1298  *
1299  * @return void
1300  *
1301  * ****************************************************************/
1302 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1303 {
1304    uint8_t ieIdx, ieIdx2;
1305    F1SetupRequest_t *f1SetupReq=NULLP;
1306
1307    if(f1apMsg != NULLP)
1308    {
1309       if(f1apMsg->choice.initiatingMessage != NULLP)
1310       {
1311          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1312          if(f1SetupReq->protocolIEs.list.array != NULLP)
1313          {
1314             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1315             {
1316                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1317                {
1318                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1319                   {
1320                      case ProtocolIE_ID_id_TransactionID:
1321                         break;
1322                      case ProtocolIE_ID_id_gNB_DU_ID:
1323                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1324                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1325                         break;
1326                      case ProtocolIE_ID_id_gNB_DU_Name:
1327                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1328                               strlen((char *)duCfgParam.duName));
1329                         break;
1330                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1331                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1332                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1333                         break;
1334                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1335                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1336                         break;
1337                      default:
1338                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1339                         break;
1340                   }
1341                }
1342             }
1343             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1344             {
1345                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1346             }
1347             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1348                   f1SetupReq->protocolIEs.list.size);
1349          }
1350          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1351       }
1352       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1353    }
1354 }
1355 /*******************************************************************
1356  *
1357  * @brief Builds and Send the F1SetupRequest
1358  *
1359  * @details
1360  *
1361  *    Function : BuildAndSendF1SetupReq
1362  *
1363  * Functionality:Fills the F1SetupRequest
1364  *
1365  * @return ROK     - success
1366  *         RFAILED - failure
1367  *
1368  ******************************************************************/
1369 uint8_t BuildAndSendF1SetupReq()
1370 {
1371    uint8_t   ret, ieIdx, elementCnt;
1372    F1AP_PDU_t                 *f1apMsg = NULLP;
1373    F1SetupRequest_t           *f1SetupReq=NULLP;
1374    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1375    RRC_Version_t              *rrcVer=NULLP;
1376    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1377    ret= RFAILED;
1378
1379    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1380    do
1381    {
1382       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1383       if(f1apMsg == NULLP)
1384       {
1385          break;
1386       }
1387       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1388       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1389       if(f1apMsg->choice.initiatingMessage == NULLP)
1390       {
1391          break;
1392       }
1393       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1394       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1395       f1apMsg->choice.initiatingMessage->value.present = \
1396                                                          InitiatingMessage__value_PR_F1SetupRequest;
1397
1398       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1399
1400       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1401
1402       f1SetupReq->protocolIEs.list.count = elementCnt;
1403       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1404
1405       /* Initialize the F1Setup members */
1406       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1407       if(f1SetupReq->protocolIEs.list.array == NULLP)
1408       {
1409          break;
1410       }
1411       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1412       {
1413          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1414                sizeof(F1SetupRequestIEs_t));
1415          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1416          {
1417             break;
1418          }
1419       }
1420
1421       ieIdx = 0;
1422       /*TransactionID*/
1423       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1424       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1425       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1426                                                                F1SetupRequestIEs__value_PR_TransactionID;
1427       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1428                                                                              TRANS_ID;
1429
1430       /*DU ID*/
1431       ieIdx++;
1432       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1433       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1434       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1435                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1436       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1437                                                                              sizeof(uint8_t);
1438
1439       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1440             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1441       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1442             NULLP)
1443       {
1444          break;
1445       }
1446
1447       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1448          duCfgParam.duId;
1449
1450       /*DU Name*/
1451       if(duCfgParam.duName != NULL)
1452       {
1453          ieIdx++;
1454          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1455          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1456          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1457          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1458             strlen((char *)duCfgParam.duName);
1459          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1460                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1461          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1462                buf == NULLP)
1463          {
1464             break;
1465          }
1466          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1467                choice.GNB_DU_Name.buf,
1468                (char*)&duCfgParam.duName);
1469
1470       }
1471
1472       /*Served Cell list */
1473       ieIdx++;
1474       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1475                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1476       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1477       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1478                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1479       duServedCell = &f1SetupReq->protocolIEs.list.\
1480                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1481       if(BuildServedCellList(duServedCell))
1482       {
1483          break;
1484       }
1485       /*RRC Version*/
1486       ieIdx++;
1487       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1488                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1489       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1490       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1491                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1492       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1493       if(BuildRrcVer(rrcVer))
1494       {
1495          break;
1496       }
1497       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1498
1499       /* Encode the F1SetupRequest type as APER */
1500       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1501       encBufSize = 0;
1502       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1503             encBuf);
1504
1505       /* Encode results */
1506       if(encRetVal.encoded == ENCODE_FAIL)
1507       {
1508          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1509                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1510          break;
1511       }
1512       else
1513       {
1514          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1515          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1516          {
1517             printf("%x",encBuf[ieIdx]);
1518          }
1519
1520          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1521          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1522          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1523          {
1524              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1525              return RFAILED;
1526          }
1527          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1528       }
1529
1530       /* Sending msg */
1531       if(sendF1APMsg() != ROK)
1532       {
1533          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1534          break;
1535       }
1536
1537       ret=ROK;
1538       break;
1539    }while(true);
1540
1541    FreeF1SetupReq(f1apMsg);
1542
1543    return ret;
1544 }/* End of BuildAndSendF1SetupReq */
1545
1546 /*******************************************************************
1547  *
1548  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1549  *
1550  * @details
1551  *
1552  *    Function : freeCellsToModifyItem
1553  *
1554  *    Functionality: Deallocating memory of variables allocated in
1555  *                    BuildAndSendDUConfigUpdate function
1556  *
1557  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1558  *
1559  * @return ROK     - void
1560  *
1561  * ****************************************************************/
1562
1563 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1564 {
1565    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1566    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1567    SliceSupportItem_t *sliceSupportItem = NULLP;
1568
1569    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1570    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1571
1572    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1573            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1574    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1575          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1576
1577    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1578    {
1579       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1580       {
1581          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1582
1583          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1584
1585          if(servedPlmnItem->iE_Extensions != NULLP)
1586          {
1587             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1588             {
1589                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1590                {
1591                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1592                         list.array != NULLP)
1593                   {
1594                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1595                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1596                      {
1597                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1598                               list.array[sliceLstIdx] != NULLP)
1599                         {
1600
1601                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1602                                               SliceSupportList.list.array[sliceLstIdx];
1603
1604                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1605                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1606                            {
1607                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1608                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1609                            }
1610                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1611                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1612                         }
1613                      }
1614                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1615                            choice.SliceSupportList.list.array,\
1616                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1617                            extensionValue.choice.SliceSupportList.list.size);
1618                   }
1619                }
1620                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1621                {
1622                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1623                }
1624                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1625             }
1626             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1627          }
1628       }
1629       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1630       {
1631          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1632       }
1633       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1634          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1635    }
1636
1637    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1638    {
1639       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1640    }
1641    else
1642    {
1643       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1644       {
1645          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1646          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1647       }
1648    }
1649    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1650       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1651 }
1652
1653 /*******************************************************************
1654  *
1655  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1656  *
1657  * @details
1658  *
1659  *    Function : FreeDUConfigUpdate
1660  *
1661  *    Functionality: Deallocating memory of variables allocated in
1662  *                    BuildAndSendDUConfigUpdate function
1663  *
1664  * @params[in]  F1AP_PDU_t *f1apDuCfg
1665  *
1666  * @return ROK     - void
1667  *
1668  * ****************************************************************/
1669 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1670 {
1671    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1672    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1673    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1674    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1675    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1676    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1677
1678    if(f1apDuCfg != NULLP)
1679    {
1680       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1681       {
1682          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1683                        value.choice.GNBDUConfigurationUpdate;
1684          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1685          {
1686             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1687             {
1688                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1689                {
1690                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1691                   {
1692                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1693                         {
1694                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1695                                            value.choice.Served_Cells_To_Modify_List;
1696                            if(cellsToModify->list.array != NULLP)
1697                            {
1698                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1699                               {
1700                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1701                                  {
1702                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1703                                           Served_Cells_To_Modify_Item);
1704                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1705                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1706                                  }
1707                               }
1708                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1709                            }
1710                            break;
1711                         }
1712                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1713                         {
1714                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1715                                            value.choice.Served_Cells_To_Delete_List;
1716                            if(cellsToDelete->list.array != NULLP)
1717                            {
1718                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1719                               {
1720                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1721                                  {
1722                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1723                                           cellsToDelete->list.array[cellDeleteIdx]);
1724                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1725                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1726                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1727                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1728                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1729                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1730                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1731                                  }
1732                               }
1733                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1734                            }
1735
1736                            break;
1737                         }
1738                      case ProtocolIE_ID_id_gNB_DU_ID:
1739                         {
1740                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1741                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1742                            break;
1743                         }
1744                   }
1745                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1746                         sizeof(GNBDUConfigurationUpdateIEs_t));
1747                }
1748             }
1749             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1750          }
1751          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1752       }
1753       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1754    }
1755 }
1756
1757 /*******************************************************************
1758  *
1759  * @brief Fills Served Plmns required in ServCellInfo IE
1760  *
1761  * @details
1762  *
1763  *    Function : fillServedPlmns
1764  *
1765  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1766  *
1767  * @params[in] Pointer to ServedPLMNs_List_t *
1768  *
1769  * @return ROK     - success
1770  *         RFAILED - failure
1771  *
1772  *****************************************************************/
1773
1774 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1775 {
1776    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1777
1778    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1779    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1780          array[arrayIdx]->pLMN_Identity.size);
1781    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1782    {
1783       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1784       return RFAILED;
1785    }
1786    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1787          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1788    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1789    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1790    {
1791       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1792       return RFAILED;
1793    }
1794
1795    ieListCnt=1;
1796    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1797    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1798    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1799          iE_Extensions->list.size);
1800    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1801    {
1802       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1803       return RFAILED;
1804    }
1805    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1806    {
1807       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1808             sizeof(ServedPLMNs_ItemExtIEs_t));
1809       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1810       {
1811          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1812          return RFAILED;
1813       }
1814    }
1815
1816    ieIdx = 0;
1817    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1818    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1819    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1820    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1821    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1822    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1823       list.count = elementCnt;
1824    servedPlmn->list.array[arrayIdx]->\
1825       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1826       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1827    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1828          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1829          list.array,servedPlmn->list.array[arrayIdx]->\
1830          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1831    if(servedPlmn->list.array[arrayIdx]->\
1832          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1833          list.array == NULLP)
1834    {
1835       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1836       return RFAILED;
1837    }
1838
1839    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1840    {
1841       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1842       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1843       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1844       if(servedPlmn->list.array[arrayIdx]->\
1845       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1846       list.array[sliceLstIdx] == NULLP)
1847       {
1848          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1849          return RFAILED;
1850       }
1851
1852       servedPlmn->list.array[arrayIdx]->\
1853       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1854       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1855       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1856       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1857       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1858       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1859       sNSSAI.sST.size);
1860
1861       if(servedPlmn->list.array[arrayIdx]->\
1862       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1863       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1864       {
1865          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1866          return RFAILED;
1867       }
1868       servedPlmn->list.array[arrayIdx]->\
1869       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1870       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1871       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1872
1873       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1874       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1875       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1876       if(servedPlmn->list.array[arrayIdx]->\
1877       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1878       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1879       {
1880          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1881          return RFAILED;
1882       }
1883       servedPlmn->list.array[arrayIdx]->\
1884       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1885       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1886       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1887       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1888       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1889       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1890       list.array[sliceLstIdx]->sNSSAI.sD->size);
1891       if(servedPlmn->list.array[arrayIdx]->\
1892       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1893       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1894       {
1895          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1896          return RFAILED;
1897       }
1898       memcpy(servedPlmn->list.array[arrayIdx]->\
1899       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1900       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1901       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1902       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1903       list.array[sliceLstIdx]->sNSSAI.sD->size);
1904    }
1905    return ROK;
1906 }
1907
1908 /*******************************************************************
1909  *
1910  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1911  *
1912  * @details
1913  *
1914  *    Function : fillNrFddInfo
1915  *
1916  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1917  *
1918  * @params[in] FDD_Info_t *fDD
1919  *
1920  * @return ROK     - success
1921  *         RFAILED - failure
1922  *
1923  *****************************************************************/
1924
1925 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1926 {
1927    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1928       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1929    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1930    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1931    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1932          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1933    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1934    {
1935       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1936       return RFAILED;
1937    }
1938
1939    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1940       sizeof(FreqBandNrItem_t));
1941    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1942    {
1943       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1944       return RFAILED;
1945    }
1946
1947    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1948       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1949       freqBand[0].nrFreqBand;
1950    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1951    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1952       dlNrFreqInfo.nrArfcn;
1953    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
1954    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1955    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1956    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1957    {
1958       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1959       return RFAILED;
1960    }
1961
1962    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
1963    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1964    {
1965       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1966       return RFAILED;
1967    }
1968
1969    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1970       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1971       freqBand[0].nrFreqBand;
1972    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1973
1974    /*Transmission Bandwidth*/
1975    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1976       f1Mode.mode.fdd.ulTxBw.nrScs;
1977    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1978       f1Mode.mode.fdd.ulTxBw.nrb;
1979    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1980       f1Mode.mode.fdd.dlTxBw.nrScs;
1981    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1982       f1Mode.mode.fdd.dlTxBw.nrb;
1983
1984    return ROK;
1985 }
1986
1987 /*******************************************************************
1988  *
1989  * @brief Fills ServCellInfo IE
1990  *
1991  * @details
1992  *
1993  *    Function : fillServedCellInfo
1994  *
1995  *    Functionality: Fills ServCellInfo
1996  *
1997  * @params[in] Pointer to Served_Cell_Information_t *
1998  *
1999  * @return ROK     - success
2000  *         RFAILED - failure
2001  *
2002  *****************************************************************/
2003
2004 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2005 {
2006    uint8_t ieIdx, ieListCnt;
2007
2008    /*nRCGI*/
2009    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2010    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2011          srvCellInfo->nRCGI.pLMN_Identity.size);
2012    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2013    {
2014       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2015       return RFAILED;
2016    }
2017    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2018          srvCellInfo->nRCGI.pLMN_Identity.buf);
2019    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2020    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2021          srvCellInfo->nRCGI.nRCellIdentity.size);
2022    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2023    {
2024       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2025       return RFAILED;
2026    }
2027
2028    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2029    /*nRPCI*/
2030    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2031
2032    /*servedPLMNs*/
2033    ieListCnt = 1;
2034    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2035    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2036    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2037    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2038    {
2039       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2040       return RFAILED;
2041    }
2042    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2043    {
2044       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2045       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2046       {
2047          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2048          return RFAILED;
2049       }
2050    }
2051    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2052    {
2053       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2054       return RFAILED;
2055    }
2056
2057 #ifndef NR_TDD
2058    /*nR Mode Info with FDD*/
2059    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2060    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2061    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2062    {
2063       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2064       return RFAILED;
2065    }
2066    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2067    {
2068        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2069       return RFAILED;
2070    }
2071 #else
2072    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2073    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2074    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2075    {
2076       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2077       return RFAILED;
2078    }
2079    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2080    {
2081       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2082       return RFAILED;
2083    }
2084 #endif
2085
2086    /*Measurement timing Config*/
2087    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2088    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2089          buf,srvCellInfo->measurementTimingConfiguration.size);
2090    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2091    {
2092       return RFAILED;
2093    }
2094    srvCellInfo->measurementTimingConfiguration.\
2095          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2096
2097    return ROK;
2098 }
2099
2100 /*******************************************************************
2101  *
2102  * @brief Fills ServCellToModItem IE
2103  *
2104  * @details
2105  *
2106  *    Function : fillServCellToModItem
2107  *
2108  *    Functionality: Fills ServCellToModItem IE
2109  *
2110  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2111  *
2112  * @return ROK     - success
2113  *         RFAILED - failure
2114  *
2115  *****************************************************************/
2116
2117 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2118 {
2119    /*pLMN_Identity*/
2120    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2121    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2122    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2123    {
2124       return RFAILED;
2125    }
2126    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2127          modifyItem->oldNRCGI.pLMN_Identity.buf);
2128
2129    /*nRCellIdentity*/
2130    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2131    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2132          modifyItem->oldNRCGI.nRCellIdentity.size);
2133    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2134    {
2135       return RFAILED;
2136    }
2137    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2138
2139    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2140       return RFAILED;
2141    else
2142       return ROK;
2143 }
2144
2145 /*******************************************************************
2146  *
2147  * @brief Builds ServCellToModList
2148  *
2149  * @details
2150  *
2151  *    Function : buildServCellToModList
2152  *
2153  *    Functionality: Builds the serv cell to Mod List
2154  *
2155  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2156  *
2157  * @return ROK     - success
2158  *         RFAILED - failure
2159  *
2160  *****************************************************************/
2161
2162 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2163 {
2164    uint8_t ieListCnt, ieIdx;
2165    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2166
2167    ieListCnt = 1;
2168    cellsToModify->list.count = ieListCnt;
2169    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2170    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2171    if(cellsToModify->list.array == NULLP)
2172    {
2173       return RFAILED;
2174    }
2175    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2176    {
2177       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2178       if(cellsToModify->list.array[ieIdx] == NULLP)
2179       {
2180          return RFAILED;
2181       }
2182    }
2183    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2184    cellsToModify->list.array[0]->criticality = Criticality_reject;
2185    cellsToModify->list.array[0]->value.present =\
2186       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2187    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2188
2189    if(fillServCellToModItem(modifyItem))
2190       return RFAILED;
2191    else
2192       return ROK;
2193 }
2194 /*******************************************************************
2195  *
2196  * @brief filling the DeleteItemList
2197  *
2198  * @details
2199  *
2200  *    Function : fillCellToDeleteItem
2201  *
2202  *    Functionality: Filling the DeleteItemIe
2203  *
2204  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2205  *
2206  * @return ROK     - success
2207  *         RFAILED - failure
2208  *
2209  *****************************************************************/
2210 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2211 {
2212    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2213
2214    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2215    deleteItemIe->criticality = Criticality_reject;
2216    deleteItemIe->value.present =\
2217    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2218    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2219
2220    /*pLMN_Identity*/
2221    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2222    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2223    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2224    {
2225       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2226       return RFAILED;
2227    }
2228    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2229          deleteItem->oldNRCGI.pLMN_Identity.buf);
2230
2231    /*nRCellIdentity*/
2232    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2233    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2234          deleteItem->oldNRCGI.nRCellIdentity.size);
2235    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2236    {
2237       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2238       return RFAILED;
2239    }
2240    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2241    return ROK;
2242 }
2243 /*******************************************************************
2244  *
2245  * @brief Builds ServCellToDeleteList
2246  *
2247  * @details
2248  *
2249  *    Function : buildServCellToDeleteList
2250  *
2251  *    Functionality: Builds the serv cell to delete List
2252  *
2253  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2254  *
2255  * @return ROK     - success
2256  *         RFAILED - failure
2257  *
2258  *****************************************************************/
2259
2260 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2261 {
2262    uint8_t ieListCnt, arrIdx;
2263
2264    ieListCnt = 1;
2265    cellsToDelete->list.count = ieListCnt;
2266    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2267
2268    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2269    if(cellsToDelete->list.array == NULLP)
2270    {
2271       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2272       return RFAILED;
2273    }
2274
2275    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2276    {
2277       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2278       if(cellsToDelete->list.array[arrIdx] == NULLP)
2279       {
2280          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2281          return RFAILED;
2282       }
2283    }
2284
2285    arrIdx=0;
2286    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2287    {
2288       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2289       return RFAILED;
2290    }
2291    return ROK;
2292 }
2293
2294 /*******************************************************************
2295  *
2296  * @brief Builds and sends the DUConfigUpdate
2297  *
2298  * @details
2299  *
2300  *    Function : BuildAndSendDUConfigUpdate
2301  *
2302  *    Functionality: Constructs the DU Update message and sends
2303  *                   it to the CU through SCTP.
2304  *
2305  * @params[in] void **buf,Buffer to which encoded pattern is written into
2306  * @params[in] int *size,size of buffer
2307  *
2308  * @return ROK     - success
2309  *         RFAILED - failure
2310  *
2311  * ****************************************************************/
2312 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2313 {
2314    uint8_t ret =0, ieIdx=0, elementCnt=0;
2315    bool memAlloctionFailure = false;
2316    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2317    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2318    asn_enc_rval_t encRetVal;     /* Encoder return value */
2319
2320    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2321    ret= RFAILED;
2322
2323    while(true)
2324    {
2325       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2326       /* Allocate the memory for F1DuCfg */
2327       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2328       if(f1apDuCfg == NULLP)
2329       {
2330          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2331          break;
2332       }
2333
2334       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2335       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2336       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2337       {
2338          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2339          break;
2340       }
2341
2342       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2343                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2344       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2345       f1apDuCfg->choice.initiatingMessage->value.present = \
2346                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2347       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2348                     choice.GNBDUConfigurationUpdate;
2349       elementCnt = 3;
2350       duCfgUpdate->protocolIEs.list.count = elementCnt;
2351       duCfgUpdate->protocolIEs.list.size = \
2352                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2353
2354       /* Initialize the F1Setup members */
2355       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2356       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2357       {
2358          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2359          break;
2360       }
2361       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2362       {
2363          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2364          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2365          {
2366             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2367             memAlloctionFailure = true;
2368             break;
2369          }
2370       }
2371
2372       if(memAlloctionFailure == true)
2373       {
2374          break;
2375       }
2376       /*TransactionID*/
2377       ieIdx = 0;
2378       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2379       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2380       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2381       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2382       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2383
2384       ieIdx++;
2385       if(servCellAction == SERV_CELL_TO_MODIFY)
2386       {
2387          /*Served Cell to Modify */
2388          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2389          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2390          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2391          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2392          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2393          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2394                   Served_Cells_To_Modify_List))
2395          {
2396             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2397             break;
2398          }
2399       }
2400       else
2401       {
2402          /*Served Cell to Delete */
2403          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2404          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2405          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2406          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2407          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2408          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2409          Served_Cells_To_Delete_List)!=ROK)
2410          {
2411             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2412             break;
2413          }
2414
2415       }
2416       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2417       /*GNB DU ID */
2418       ieIdx++;
2419       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2420       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2421       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2422       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2423       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2424       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2425             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2426       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2427       {
2428          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2429          break;
2430       }
2431       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2432
2433       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2434
2435       /* Encode the DU Config Update type as APER */
2436       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2437       encBufSize = 0;
2438       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2439
2440       /* Checking encode results */
2441       if(encRetVal.encoded == ENCODE_FAIL)
2442       {
2443          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2444                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2445          break;
2446       }
2447       else
2448       {
2449          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2450          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2451          {
2452             printf("%x",encBuf[ieIdx]);
2453          }
2454       }
2455       /* Sending msg */
2456       if(sendF1APMsg() != ROK)
2457       {
2458          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2459          break;
2460       }
2461
2462       ret = ROK;
2463       break;
2464    }
2465
2466    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2467    return ret;
2468 }
2469
2470
2471 /*******************************************************************
2472  *
2473  * @brief free the ULRRCMessageTransfer
2474  *
2475  * @details
2476  *
2477  *    Function : FreeULRRCMessageTransfer
2478  *
2479  *    Functionality: Deallocating the memory of variable allocated in
2480  *                      FreeULRRCMessageTransfer
2481  *
2482  * @params[in]
2483  *
2484  * @return ROK     - void
2485  *
2486  ******************************************************************/
2487 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2488 {
2489    uint8_t idx1;
2490    ULRRCMessageTransfer_t  *ulRRCMsg;
2491
2492    if(f1apMsg != NULLP)
2493    {
2494       if(f1apMsg->choice.initiatingMessage != NULLP)
2495       {
2496          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2497          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2498          {
2499             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2500             {
2501                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2502                {
2503                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2504                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2505                   {
2506                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2507                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2508                   }
2509                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2510                }
2511             }
2512             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2513          }
2514          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2515       }
2516       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2517    }
2518 }
2519 /*******************************************************************
2520  *
2521  * @brief Builds and sends the ULRRCMessageTransfer
2522  *
2523  * @details
2524  *
2525  *    Function : BuildAndSendULRRCMessageTransfer
2526  *
2527  *    Functionality: Constructs the UL RRC Message Transfer and sends
2528  *                   it to the CU through SCTP.
2529  *
2530  * @params[in]
2531  *
2532  * @return ROK     - success
2533  *         RFAILED - failure
2534  *
2535  * ****************************************************************/
2536 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2537       uint16_t msgLen, uint8_t *rrcMsg)
2538 {
2539    uint8_t   elementCnt =0;
2540    uint8_t   idx1 =0;
2541    uint8_t   idx =0;
2542    F1AP_PDU_t                   *f1apMsg = NULLP;
2543    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2544    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2545    uint8_t ret =RFAILED;
2546
2547    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2548
2549    while(true)
2550    {
2551       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2552
2553       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2554       if(f1apMsg == NULLP)
2555       {
2556          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2557          break;
2558       }
2559       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2560       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2561       if(f1apMsg->choice.initiatingMessage == NULLP)
2562       {
2563          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2564          break;
2565       }
2566       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2567       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2568       f1apMsg->choice.initiatingMessage->value.present = \
2569                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2570       ulRRCMsg =
2571          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2572       elementCnt = 4;
2573       ulRRCMsg->protocolIEs.list.count = elementCnt;
2574       ulRRCMsg->protocolIEs.list.size = \
2575                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2576
2577       /* Initialize the F1Setup members */
2578       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2579       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2580       {
2581          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2582          break;
2583       }
2584       for(idx=0; idx<elementCnt; idx++)
2585       {
2586          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2587          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2588          {
2589             break;
2590          }
2591       }
2592
2593       idx1 = 0;
2594
2595       /*GNB CU UE F1AP ID*/
2596       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2597       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2598       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2599                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2600       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2601
2602       /*GNB DU UE F1AP ID*/
2603       idx1++;
2604       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2605       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2606       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2607                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2608       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2609
2610       /*SRBID*/
2611       idx1++;
2612       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2613       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2614       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2615                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2616       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2617
2618       /*RRCContainer*/
2619       idx1++;
2620       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2621       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2622       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2623                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2624       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2625       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2626             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2627       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2628       {
2629          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2630          break;
2631       }
2632       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2633       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2634             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2635
2636       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2637
2638       /* Encode the F1SetupRequest type as APER */
2639       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2640       encBufSize = 0;
2641       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2642             encBuf);
2643       /* Encode results */
2644       if(encRetVal.encoded == ENCODE_FAIL)
2645       {
2646          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2647                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2648          break;
2649       }
2650       else
2651       {
2652          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2653          for(int i=0; i< encBufSize; i++)
2654          {
2655             printf("%x",encBuf[i]);
2656          }
2657       }
2658
2659       /* Sending  msg  */
2660       if(sendF1APMsg()  !=      ROK)
2661       {
2662          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2663          break;
2664       }
2665       ret = ROK;
2666       break;
2667    }
2668    FreeULRRCMessageTransfer(f1apMsg);
2669
2670    return ret;
2671 }/* End of BuildAndSendULRRCMessageTransfer*/
2672
2673 /*******************************************************************
2674  *
2675  * @brief Builds tag config
2676  *
2677  * @details
2678  *
2679  *    Function : BuildTagConfig
2680  *
2681  *    Functionality: Builds tag config in MacCellGroupConfig
2682  *
2683  * @params[in] TAG_Config *tag_Config
2684  *
2685  * @return ROK     - success
2686  *         RFAILED - failure
2687  *
2688  * ****************************************************************/
2689 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2690 {
2691    struct TAG_Config__tag_ToAddModList *tagList;
2692    uint8_t                     idx, elementCnt;
2693
2694    tagConfig->tag_ToReleaseList = NULLP;
2695    tagConfig->tag_ToAddModList = NULLP;
2696    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2697    if(!tagConfig->tag_ToAddModList)
2698    {
2699       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2700       return RFAILED;
2701    }
2702
2703    if(ueCb == NULLP)
2704       elementCnt = ODU_VALUE_ONE;
2705    else
2706       elementCnt = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2707
2708    tagList = tagConfig->tag_ToAddModList;
2709    tagList->list.count = elementCnt;
2710    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2711
2712    tagList->list.array = NULLP;
2713    DU_ALLOC(tagList->list.array, tagList->list.size);
2714    if(!tagList->list.array)
2715    {
2716       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2717       return RFAILED;
2718    }
2719
2720    for(idx=0; idx<tagList->list.count; idx++)
2721    {
2722       tagList->list.array[idx] = NULLP;
2723       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2724       if(!tagList->list.array[idx])
2725       {
2726          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2727          return RFAILED;
2728       }
2729    }
2730
2731    if(ueCb == NULLP)
2732    {
2733       idx = 0;
2734       tagList->list.array[idx]->tag_Id = TAG_ID;
2735       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2736    }
2737    else
2738    {
2739       for(idx=0; idx<tagList->list.count; idx++)
2740       {
2741          tagList->list.array[idx]->tag_Id = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2742          tagList->list.array[idx]->timeAlignmentTimer = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2743       }
2744    }
2745
2746    return ROK;
2747 }
2748
2749 /*******************************************************************
2750  *
2751  * @brief Builds PHR Config
2752  *
2753  * @details
2754  *
2755  *    Function : BuildPhrConfig
2756  *
2757  *    Functionality: Builds phrConfig in MacCellGroupConfig
2758  *
2759  * @params[in] PHR Config *
2760  *
2761  * @return ROK     - success
2762  *         RFAILED - failure
2763  *
2764  * ****************************************************************/
2765 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2766 {
2767
2768    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2769    phrConfig->choice.setup = NULLP;
2770    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2771    if(!phrConfig->choice.setup)
2772    {
2773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2774       return RFAILED;
2775    }
2776
2777    if(ueCb == NULLP)
2778    {
2779       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2780       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2781       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2782       phrConfig->choice.setup->multiplePHR              = false;
2783       phrConfig->choice.setup->dummy                    = false;
2784       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2785       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2786    }
2787    else
2788    {
2789       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2790       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2791       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->macUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2792       phrConfig->choice.setup->multiplePHR              = ueCb->macUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2793       phrConfig->choice.setup->dummy                    = ueCb->macUeCfg.macCellGrpCfg.phrCfg.dummy;
2794       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2795       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2796    }
2797
2798    return ROK;
2799 }
2800
2801 /*******************************************************************
2802  *
2803  * @brief Builds BSR Config
2804  *
2805  * @details
2806  *
2807  *    Function : BuildBsrConfig
2808  *
2809  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2810  *
2811  * @params[in] BSR_Config *bsrConfig
2812  *
2813  * @return ROK     - success
2814  *         RFAILED - failure
2815  *
2816  * ****************************************************************/
2817 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2818 {
2819    if(ueCb == NULLP)
2820    {
2821       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2822       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2823       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2824    }
2825    else
2826    {
2827       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2828       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2829
2830       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2831       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2832       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2833       {
2834          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2835          return RFAILED;
2836       }
2837       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2838    }
2839
2840    return ROK;
2841 }
2842
2843 /*******************************************************************
2844  *
2845  * @brief Builds scheduling request config
2846  *
2847  * @details
2848  *
2849  *    Function : BuildSchedulingReqConfig
2850  *
2851  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2852  *
2853  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2854  *
2855  * @return ROK     - success
2856  *         RFAILED - failure
2857  *
2858  * ****************************************************************/
2859 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2860 {
2861    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2862    uint8_t                     idx, elementCnt;
2863
2864    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2865    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2866          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2867    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2868    {
2869       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2870       return RFAILED;
2871    }
2872
2873    if(ueCb == NULLP)
2874       elementCnt = ODU_VALUE_ONE;
2875    else
2876       elementCnt = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2877
2878    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2879    schReqList->list.count = elementCnt;
2880    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2881
2882    schReqList->list.array = NULLP;
2883    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2884    if(!schReqList->list.array)
2885    {
2886       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2887       return RFAILED;
2888    }
2889
2890    for(idx=0; idx<schReqList->list.count; idx++)
2891    {
2892       schReqList->list.array[idx] = NULLP;
2893       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2894       if(!schReqList->list.array[idx])
2895       {
2896          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2897          return RFAILED;
2898       }
2899    }
2900
2901    if(ueCb == NULLP)
2902    {
2903       idx = 0;
2904       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2905
2906       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2907       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2908       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2909       {
2910          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2911          return RFAILED;
2912       }
2913       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2914       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2915    }
2916    else
2917    {
2918       for(idx=0; idx<schReqList->list.count; idx++)
2919       {
2920          schReqList->list.array[idx]->schedulingRequestId = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2921
2922          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2923          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2924          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2925          {
2926             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2927             return RFAILED;
2928          }
2929          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2930          schReqList->list.array[idx]->sr_TransMax = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2931       }
2932    }
2933
2934    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2935
2936    return ROK;
2937 }
2938
2939 /*******************************************************************
2940  *
2941  * @brief Builds RLC Configuration for AM mode
2942  *
2943  * @details
2944  *
2945  *    Function : BuildRlcConfigAm
2946  *
2947  *    Functionality:
2948  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
2949  *
2950  * @params[in] AmBearerCfg *amCfg
2951  *             RLC_Config_t  *rlcConfig
2952  *
2953  * @return ROK     - success
2954  *         RFAILED - failure
2955  *
2956  * ****************************************************************/
2957 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
2958 {
2959    rlcConfig->choice.am = NULLP;
2960    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2961    if(!rlcConfig->choice.am)
2962    {
2963       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2964       return RFAILED;
2965    }
2966
2967    /* Fill AM UL configuration */
2968    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2969    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2970    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2971    {
2972       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2973       return RFAILED;
2974    }
2975
2976    /* Fill default AM UL configuration if input pointer to DU database is NULL */
2977    if(amCfg == NULLP)
2978    {
2979       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2980       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2981       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2982       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2983       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2984    }
2985    else
2986    {
2987       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
2988       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
2989       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
2990       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
2991       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
2992    }
2993
2994    /* Fill AM DL configuraion */
2995    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2996    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2997    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2998    {
2999       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3000       return RFAILED;
3001    }
3002
3003    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3004    if(amCfg == NULLP)
3005    {
3006       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3007       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3008       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3009    }
3010    else /* Fill AM configuration from DU database */
3011    {
3012       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3013       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3014       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3015    }
3016    return ROK;
3017 }
3018
3019 /*******************************************************************
3020  *
3021  * @brief Builds RLC Config for UM Bidirection
3022  *
3023  * @details
3024  *
3025  *    Function : BuildRlcConfig UmBiDir
3026  *
3027  *    Functionality:
3028  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3029  *
3030  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3031  *             RLC_Config_t *rlcConfig
3032  *
3033  * @return ROK     - success
3034  *         RFAILED - failure
3035  *
3036  * ****************************************************************/
3037 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3038 {
3039    rlcConfig->choice.um_Bi_Directional = NULLP;
3040    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3041    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3042    {
3043       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3044       return RFAILED;
3045    }
3046
3047    /* Fill UM Bidirectional UL configuration */
3048    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3049    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3050    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3051    {
3052       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3053       return RFAILED;
3054    }
3055
3056    if(umBiDirCfg != NULLP)
3057    {
3058       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3059    }
3060
3061    /* Fill UM Bidirectional DL configuration */
3062    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3063    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3064    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3065    {
3066       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3067       return RFAILED;
3068    }
3069
3070    if(umBiDirCfg != NULLP)
3071    {
3072       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3073       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3074    }
3075
3076    return ROK;
3077 }
3078
3079 /*******************************************************************
3080  *
3081  * @brief Builds RLC Config for UM Uni directional UL
3082  *
3083  * @details
3084  *
3085  *    Function : BuildRlcConfigUmUniDirUl
3086  *
3087  *    Functionality:
3088  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3089  *
3090  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3091  *             RLC_Config_t *rlcConfig
3092  *
3093  * @return ROK     - success
3094  *         RFAILED - failure
3095  *
3096  * ****************************************************************/
3097 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3098 {
3099    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3100    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3101    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3102    {
3103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3104       return RFAILED;
3105    }
3106
3107    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3108    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3109    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3110    {
3111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3112       return RFAILED;
3113    }
3114
3115    if(umUniDirDlCfg != NULLP)
3116    {
3117       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3118    }
3119
3120    return ROK;
3121 }
3122
3123 /*******************************************************************
3124  *
3125  * @brief Builds RLC Config for UM Uni directional DL
3126  *
3127  * @details
3128  *
3129  *    Function : BuildRlcConfigUmUniDirDl
3130  *
3131  *    Functionality:
3132  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3133  *
3134  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3135  *             RLC_Config_t *rlcConfig
3136  *
3137  * @return ROK     - success
3138  *         RFAILED - failure
3139  *
3140  * ****************************************************************/
3141 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3142 {
3143    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3144    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3145    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3146    {
3147       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3148       return RFAILED;
3149    }
3150
3151    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3152    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3153    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3154    {
3155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3156       return RFAILED;
3157    }
3158
3159    if(umUniDirUlCfg != NULLP)
3160    {
3161       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3162       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3163    }
3164
3165    return ROK;
3166 }
3167
3168 /*******************************************************************
3169  *
3170  * @brief Builds RLC Config
3171  *
3172  * @details
3173  *
3174  *    Function : BuildRlcConfig
3175  *
3176  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3177  *
3178  * @params[in] RLC_Config_t *rlcConfig
3179  *
3180  * @return ROK     - success
3181  *         RFAILED - failure
3182  *
3183  * ****************************************************************/
3184 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3185 {
3186
3187    /* Fill default values if rbCfg is NULL */
3188    if(rbCfg == NULLP)
3189    {
3190       rlcConfig->present = RLC_Config_PR_am;
3191       BuildRlcConfigAm(NULLP, rlcConfig);
3192    }
3193    /* If RbCfg is present, fill RLC configurations from DU Database */
3194    else
3195    {
3196       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3197       switch(rlcConfig->present)
3198       {
3199          case RLC_Config_PR_am:
3200             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3201             break;
3202          case RLC_Config_PR_um_Bi_Directional:
3203             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3204             break;
3205          case RLC_Config_PR_um_Uni_Directional_UL:
3206             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3207             break;
3208          case RLC_Config_PR_um_Uni_Directional_DL:
3209             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3210             break;
3211          case RLC_Config_PR_NOTHING:
3212          default:
3213             break;
3214       }
3215    }
3216
3217    return ROK;
3218 }
3219
3220 /*******************************************************************
3221  *
3222  * @brief Builds MAC LC Config
3223  *
3224  * @details
3225  *
3226  *    Function : BuildMacLCConfig
3227  *
3228  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3229  *
3230  * @params[in] struct LogicalChannelConfig macLcConfig
3231  *
3232  * @return ROK     - success
3233  *         RFAILED - failure
3234  *
3235  * ****************************************************************/
3236 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3237 {
3238    macLcConfig->ul_SpecificParameters = NULLP;
3239    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3240    if(!macLcConfig->ul_SpecificParameters)
3241    {
3242       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3243       return RFAILED;
3244    }
3245
3246    if(lcCfgDb == NULLP)
3247    {
3248       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3249       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3250       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3251    }
3252    else
3253    {
3254       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3255       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3256       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3257    }
3258
3259    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3260    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3261    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3262    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3263
3264    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3265    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3266    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3267    {
3268       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3269       return RFAILED;
3270    }
3271
3272    if(lcCfgDb == NULLP)
3273       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3274    else
3275       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3276
3277    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3278    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3279    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3280    {
3281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3282       return RFAILED;
3283    }
3284
3285    if(lcCfgDb == NULLP)
3286       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3287    else
3288       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3289
3290    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3291    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3292    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3293
3294    return ROK;
3295 }
3296
3297 /*******************************************************************
3298  *
3299  * @brief Builds RLC Bearer to Add/Mod list
3300  *
3301  * @details
3302  *
3303  *    Function :BuildRlcBearerToAddModList
3304  *
3305  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3306  *
3307  * @params[in] rlc_BearerToAddModList
3308  *
3309  * @return ROK     - success
3310  *         RFAILED - failure
3311  *
3312  * ****************************************************************/
3313 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3314 {
3315    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3316
3317    if(ueCb == NULLP)
3318       elementCnt = 1;
3319    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3320       elementCnt = ueCb->rlcUeCfg.numLcs;
3321    else
3322    {
3323       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3324       {
3325          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3326             elementCnt++;
3327       }
3328    }
3329    rlcBearerList->list.count = elementCnt;
3330    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3331
3332    rlcBearerList->list.array = NULLP;
3333    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3334    if(!rlcBearerList->list.array)
3335    {
3336       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3337       return RFAILED;
3338    }
3339
3340    for(idx=0; idx<rlcBearerList->list.count; idx++)
3341    {
3342       rlcBearerList->list.array[idx] = NULLP;
3343       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3344       if(!rlcBearerList->list.array[idx])
3345       {
3346          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3347          return RFAILED;
3348       }
3349    }
3350
3351    if(ueCb == NULLP)
3352    {
3353       idx=0;
3354       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3355       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3356       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3357       {
3358          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3359          return RFAILED;
3360       }
3361       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3362       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3363       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3364
3365       /* Fill RLC related Configurations for this Radio Bearer */
3366       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3367       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3368       if(!rlcBearerList->list.array[idx]->rlc_Config)
3369       {
3370          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3371          return RFAILED;
3372       }
3373       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3374       {
3375          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3376          return RFAILED;
3377       }
3378
3379       /* Fill MAC related configurations for this Radio Bearer */
3380       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3381       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3382       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3383       {
3384          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3385          return RFAILED;
3386       }
3387       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3388       {
3389          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3390          return RFAILED;
3391       }
3392    }
3393    else
3394    {
3395       idx=0;
3396       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3397       {
3398          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3399             continue;
3400
3401          /* Fill Logical channel identity */
3402          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3403
3404          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3405          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3406          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3407          {
3408             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3409             return RFAILED;
3410          }
3411          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3412                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3413          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3414          {
3415             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3416                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3417                break;
3418             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3419                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3420                break;
3421             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3422             default:
3423                break;
3424          }
3425          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3426
3427          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3428
3429          /* Fill RLC related Configurations for this Radio Bearer */
3430          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3431          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3432          if(!rlcBearerList->list.array[idx]->rlc_Config)
3433          {
3434             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3435             return RFAILED;
3436          }
3437          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3438          {
3439             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3440             return RFAILED;
3441          }
3442
3443          /* Fill MAC related configurations for this Radio Bearer */
3444          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3445          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3446          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3447          {
3448             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3449             return RFAILED;
3450          }
3451          for(macLcIdx = 0; macLcIdx < ueCb->macUeCfg.numLcs; macLcIdx++)
3452          {
3453             if(ueCb->macUeCfg.lcCfgList[macLcIdx].lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3454             {
3455                if(BuildMacLCConfig(&ueCb->macUeCfg.lcCfgList[macLcIdx], rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3456                {
3457                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3458                   return RFAILED;
3459                }
3460                break;
3461             }
3462          }
3463
3464          idx++;
3465       }
3466    }
3467    return ROK;
3468 }
3469
3470 /*******************************************************************
3471  *
3472  * @brief Build Control resource set to add/modify list
3473  *
3474  * @details
3475  *
3476  *    Function : BuildControlRSetToAddModList
3477  *
3478  *    Functionality: Build Control resource set to add/modify list
3479  *
3480  * @params[in]
3481  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3482  *
3483  * @return ROK     - success
3484  *         RFAILED - failure
3485  *
3486  * ****************************************************************/
3487 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3488 {
3489    uint8_t idx;
3490    uint8_t elementCnt;
3491    uint8_t numBytes, bitsUnused;
3492    struct ControlResourceSet *controlRSet;
3493    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3494    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3495
3496    if(pdcchCfg == NULLP)
3497       elementCnt = 1;
3498    else
3499       elementCnt = pdcchCfg->numCRsetToAddMod;
3500
3501    controlRSetList->list.count = elementCnt;
3502    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3503
3504    controlRSetList->list.array = NULLP;
3505    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3506    if(!controlRSetList->list.array)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3509       return RFAILED;
3510    }
3511
3512    for(idx = 0; idx < elementCnt; idx++)
3513    {
3514       controlRSetList->list.array[idx] = NULLP;
3515       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3516       if(!controlRSetList->list.array[idx])
3517       {
3518          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3519          return RFAILED;
3520       }
3521    }
3522
3523    for(idx = 0; idx < elementCnt; idx++)
3524    {
3525       controlRSet = controlRSetList->list.array[idx];
3526
3527       if(pdcchCfg == NULLP)
3528          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3529       else
3530          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3531
3532       /* size 6 bytes
3533        * 3 LSBs unsued
3534        * Bit string stored ff0000000000
3535        */
3536       numBytes = 6;
3537       bitsUnused = 3;
3538       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3539
3540       controlRSet->frequencyDomainResources.buf = NULLP;
3541       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3542       if(!controlRSet->frequencyDomainResources.buf)
3543       {
3544          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3545          return RFAILED;
3546       }
3547
3548       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3549
3550       if(pdcchCfg == NULLP)
3551       {
3552          coreset0EndPrb = CORESET0_END_PRB;
3553          coreset1StartPrb = coreset0EndPrb + 6;
3554          coreset1NumPrb = CORESET1_NUM_PRB;
3555          /* calculate the PRBs */
3556          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3557          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3558          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3559
3560          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3561          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3562          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3563       }
3564       else
3565       {
3566          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3567          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3568          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3569          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3570          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3571       }
3572       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3573       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3574       controlRSet->tci_PresentInDCI = NULLP;
3575
3576 #if 0
3577       uint8_t tciStateIdx;
3578
3579       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3580             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3581       if(!controlRset->tci_StatesPDCCH_ToAddList)
3582       {
3583          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3584          return RFAILED;
3585       }
3586
3587       elementCnt = 1;
3588       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3589       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3590       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3591             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3592          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3593          {
3594             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3595             return RFAILED;
3596          }
3597
3598       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3599       {
3600          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3601          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3602          {
3603             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3604             return RFAILED;
3605          }
3606       }
3607
3608       tciStateIdx = 0;
3609       /* TODO */
3610       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3611
3612       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3613       if(!controlRset->tci_PresentInDCI)
3614       {
3615          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3616          return RFAILED;
3617       }
3618       /* TODO */
3619       *(controlRset->tci_PresentInDCI);
3620 #endif
3621
3622       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3623       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3624       if(!controlRSet->pdcch_DMRS_ScramblingID)
3625       {
3626          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3627          return RFAILED;
3628       }
3629       if(pdcchCfg == NULLP)
3630          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3631       else
3632          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3633    }
3634    return ROK;
3635 } /* End BuildControlRSetToAddModList */
3636
3637 /*******************************************************************
3638  *
3639  * @brief Build search space to add/modify list
3640  *
3641  * @details
3642  *
3643  *    Function : BuildSearchSpcToAddModList
3644  *
3645  *    Functionality: Build search space to add/modify list
3646  *
3647  * @params[in]
3648  * @return ROK     - success
3649  *         RFAILED - failure
3650  *
3651  * ****************************************************************/
3652 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3653 {
3654    uint8_t idx;
3655    uint8_t numBytes;
3656    uint8_t byteIdx;
3657    uint8_t bitsUnused;
3658    uint8_t elementCnt;
3659    struct SearchSpace *searchSpc;
3660
3661    if(pdcchCfg == NULLP)
3662       elementCnt = 1;
3663    else
3664       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3665
3666    searchSpcList->list.count = elementCnt;
3667    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3668
3669    searchSpcList->list.array = NULLP;
3670    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3671    if(!searchSpcList->list.array)
3672    {
3673       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3674       return RFAILED;
3675    }
3676
3677    for(idx = 0; idx < elementCnt; idx++)
3678    {
3679       searchSpcList->list.array[idx] = NULLP;
3680       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3681       if(!searchSpcList->list.array[idx])
3682       {
3683          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3684          return RFAILED;
3685       }
3686    }
3687
3688    for(idx = 0; idx < elementCnt; idx++)
3689    {
3690       searchSpc = searchSpcList->list.array[idx];
3691
3692       if(pdcchCfg == NULLP)
3693          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3694       else
3695          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3696
3697       searchSpc->controlResourceSetId = NULLP;
3698       DU_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       if(pdcchCfg == NULLP)
3705          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3706       else
3707          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3708
3709       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3710       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3711       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3712       {
3713          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3714          return RFAILED;
3715       }
3716       if(pdcchCfg == NULLP)
3717          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3718       else
3719          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3720
3721       searchSpc->duration = NULLP;
3722       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3723       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3724       if(!searchSpc->monitoringSymbolsWithinSlot)
3725       {
3726          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3727          return RFAILED;
3728       }
3729
3730       /* Values taken from reference logs :
3731        * size 2 bytes
3732        * 2 LSBs unsued
3733        * Bit string stores 8000
3734        */
3735       numBytes = 2;
3736       bitsUnused = 2;
3737       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3738       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3739       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3740       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3741       {
3742          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3743          return RFAILED;
3744       }
3745       if(pdcchCfg == NULLP)
3746       {
3747          byteIdx = 0;
3748          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3749          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3750       }
3751       else
3752          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3753       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3754
3755       searchSpc->nrofCandidates = NULLP;
3756       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3757       if(!searchSpc->nrofCandidates)
3758       {
3759          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3760          return RFAILED;
3761       }
3762
3763       if(pdcchCfg == NULLP)
3764       {
3765          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3766          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3767          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3768          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3769          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3770       }
3771       else
3772       {
3773          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3774          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3775          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3776          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3777          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3778       }
3779
3780       searchSpc->searchSpaceType = NULLP;
3781       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3782       if(!searchSpc->searchSpaceType)
3783       {
3784          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3785          return RFAILED;
3786       }
3787       if(pdcchCfg == NULLP)
3788          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3789       else
3790          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3791
3792       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3793       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3794       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3795       {
3796          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3797          return RFAILED;
3798       }
3799       if(pdcchCfg == NULLP)
3800          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3801       else
3802          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3803    }
3804    return ROK;
3805 }/* End BuildSearchSpcToAddModList */
3806
3807 /*******************************************************************
3808  *
3809  * @brief Builds BWP DL dedicated PDCCH config
3810  *
3811  * @details
3812  *
3813  *    Function : BuildBWPDlDedPdcchCfg
3814  *
3815  *    Functionality: Builds BWP DL dedicated PDCCH config
3816  *
3817  * @params[in] struct PDCCH_Config *pdcchCfg
3818  *
3819  * @return ROK     - success
3820  *         RFAILED - failure
3821  *
3822  * ****************************************************************/
3823 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3824 {
3825    pdcchCfg->controlResourceSetToAddModList = NULLP;
3826    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3827    if(!pdcchCfg->controlResourceSetToAddModList)
3828    {
3829       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3830       return RFAILED;
3831    }
3832
3833    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3834    {
3835       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3836       return RFAILED;
3837    }
3838
3839    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3840
3841    pdcchCfg->searchSpacesToAddModList = NULLP;
3842    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3843    if(!pdcchCfg->searchSpacesToAddModList)
3844    {
3845       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3846       return RFAILED;
3847    }
3848
3849    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3850    {
3851       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3852       return RFAILED;
3853    }
3854
3855    pdcchCfg->searchSpacesToReleaseList = NULLP;
3856    pdcchCfg->downlinkPreemption = NULLP;
3857    pdcchCfg->tpc_PUSCH = NULLP;
3858    pdcchCfg->tpc_PUCCH = NULLP;
3859    pdcchCfg->tpc_SRS = NULLP;
3860
3861    return ROK;
3862 }
3863
3864 /*******************************************************************
3865  *
3866  * @brief Builds DMRS DL PDSCH Mapping type A
3867  *
3868  * @details
3869  *
3870  *    Function : BuildDMRSDLPdschMapTypeA
3871  *
3872  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3873  *
3874  * @params[in]
3875  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3876  * @return ROK     - success
3877  *         RFAILED - failure
3878  *
3879  * ****************************************************************/
3880 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3881 {
3882    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3883    dmrsDlCfg->choice.setup = NULLP;
3884    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3885    if(!dmrsDlCfg->choice.setup)
3886    {
3887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3888       return RFAILED;
3889    }
3890
3891    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3892    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3893    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3894    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3895    {
3896       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3897       return RFAILED;
3898    }
3899    if(pdschCfg == NULLP)
3900       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3901    else
3902       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3903
3904    dmrsDlCfg->choice.setup->maxLength = NULLP;
3905    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3906    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3907    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3908
3909    return ROK;
3910 }
3911
3912 /*******************************************************************
3913  *
3914  * @brief Builds TCI states to add/modify list
3915  *
3916  * @details
3917  *
3918  *    Function : BuildTCIStatesToAddModList
3919  *
3920  *    Functionality:Builds TCI states to add/modify list
3921  *
3922  * @params[in]
3923  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3924  *
3925  * @return ROK     - success
3926  *         RFAILED - failure
3927  *
3928  * ****************************************************************/
3929 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3930 {
3931    return ROK;
3932 }
3933
3934 /*******************************************************************
3935  *
3936  * @brief Builds PDSCH time domain allocation list
3937  *
3938  * @details
3939  *
3940  *    Function : BuildPdschTimeDomAllocList
3941  *
3942  *    Functionality: Builds PDSCH time domain allocation list
3943  *
3944  * @params[in]
3945  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3946  *
3947  * @return ROK     - success
3948  *         RFAILED - failure
3949  *
3950  * ****************************************************************/
3951 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
3952 {
3953    uint8_t idx;
3954    uint8_t elementCnt;
3955    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3956
3957    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3958
3959    timeDomAllocList->choice.setup = NULLP;
3960    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3961    if(!timeDomAllocList->choice.setup)
3962    {
3963       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3964       return RFAILED;
3965    }
3966
3967 if(pdschCfg == NULLP)
3968    elementCnt = 2;
3969 else
3970 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
3971    timeDomAllocList->choice.setup->list.count = elementCnt;
3972    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3973
3974    timeDomAllocList->choice.setup->list.array = NULLP;
3975    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
3976    if(!timeDomAllocList->choice.setup->list.array)
3977    {
3978       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3979       return RFAILED;
3980    }
3981
3982    for(idx = 0; idx < elementCnt; idx++)
3983    {
3984       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3985       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3986             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3987       if(!timeDomAllocList->choice.setup->list.array[idx])
3988       {
3989          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3990          return RFAILED;
3991       }
3992    }
3993
3994    if(pdschCfg == NULLP)
3995    {
3996       idx = 0;
3997       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3998       DU_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) = 0;
4005       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4006       timeDomAlloc->startSymbolAndLength = \
4007                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4008
4009       idx++;
4010       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4011       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4012       if(!timeDomAlloc->k0)
4013       {
4014          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4015          return RFAILED;
4016       }
4017       *(timeDomAlloc->k0) = 1;
4018       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4019       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4020    }
4021    else
4022    {
4023       for(idx = 0; idx < elementCnt; idx++)
4024       {
4025          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4026          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4027          if(!timeDomAlloc->k0)
4028          {
4029             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4030             return RFAILED;
4031          }
4032          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4033             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4034          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4035          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4036       }
4037    }
4038
4039    return ROK;
4040 }
4041
4042 /*******************************************************************
4043  *
4044  * @brief Builds PDSCH PRB Bundling type
4045  *
4046  * @details
4047  *
4048  *    Function : BuildPdschPrbBundlingType
4049  *
4050  *    Functionality: Builds PDSCH PRB Bundling type
4051  *
4052  * @params[in]
4053  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4054  *
4055  * @return ROK     - success
4056  *         RFAILED - failure
4057  *
4058  * ****************************************************************/
4059 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4060 {
4061    if(pdschCfg == NULLP)
4062       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4063    else
4064       prbBndlType->present = pdschCfg->bundlingType;
4065
4066    prbBndlType->choice.staticBundling = NULLP;
4067    DU_ALLOC(prbBndlType->choice.staticBundling, \
4068          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4069    if(!prbBndlType->choice.staticBundling)
4070    {
4071       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4072       return RFAILED;
4073    }
4074    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4075
4076    return ROK;
4077 }
4078
4079 /*******************************************************************
4080  *
4081  * @brief Builds BWP DL dedicated PDSCH config
4082  *
4083  * @details
4084  *
4085  *    Function : BuildBWPDlDedPdschCfg
4086  *
4087  *    Functionality: Builds BWP DL dedicated PDSCH config
4088  *
4089  * @params[in] struct PDSCH_Config *pdschCfg
4090  *
4091  * @return ROK     - success
4092  *         RFAILED - failure
4093  *
4094  * ****************************************************************/
4095 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4096 {
4097    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4098
4099    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4100    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4101    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4102    {
4103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4104       return RFAILED;
4105    }
4106
4107    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4108    {
4109       return RFAILED;
4110    }
4111
4112    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4113    pdschCfg->tci_StatesToAddModList = NULLP;
4114    pdschCfg->tci_StatesToReleaseList = NULLP;
4115    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4116 #if 0
4117    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4118    if(!pdschCfg->tci_StatesToAddModList)
4119    {
4120       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4121       return RFAILED;
4122    }
4123    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4124    {
4125       return RFAILED;
4126    }
4127 #endif
4128
4129 if(pdschCfgDb == NULLP)
4130    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4131 else
4132 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4133
4134    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4135    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4136    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4137    {
4138       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4139       return RFAILED;
4140    }
4141    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4142    {
4143       return RFAILED;
4144    }
4145
4146    pdschCfg->pdsch_AggregationFactor = NULLP;
4147    pdschCfg->rateMatchPatternToAddModList = NULLP;
4148    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4149    pdschCfg->rateMatchPatternGroup1 = NULLP;
4150    pdschCfg->rateMatchPatternGroup2 = NULLP;
4151    if(pdschCfgDb == NULLP)
4152       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4153    else
4154       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4155    pdschCfg->mcs_Table = NULLP;
4156
4157    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4158    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4159    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4160    {
4161       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4162       return RFAILED;
4163    }
4164    if(pdschCfgDb == NULLP)
4165       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4166    else
4167       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4168
4169    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4170    {
4171       return RFAILED;
4172    }
4173
4174    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4175    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4176    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4177    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4178    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4179    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4180    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4181
4182    return ROK;
4183 }
4184
4185 /*******************************************************************
4186  *
4187  * @brief Builds intitial DL BWP
4188  * @details
4189  *
4190  *    Function : BuildInitialDlBWP
4191  *
4192  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4193  *
4194  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4195  *
4196  * @return ROK     - success
4197  *         RFAILED - failure
4198  *
4199  * ****************************************************************/
4200 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4201 {
4202    PdcchConfig *pdcchCfg = NULLP;
4203    PdschConfig *pdschCfg = NULLP;
4204
4205    if(initiDlBwp)
4206    {
4207       if(initiDlBwp->pdcchPresent)
4208          pdcchCfg = &initiDlBwp->pdcchCfg;
4209       if(initiDlBwp->pdschPresent)
4210          pdschCfg = &initiDlBwp->pdschCfg;
4211    }
4212
4213    dlBwp->pdcch_Config = NULLP;
4214    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4215    if(!dlBwp->pdcch_Config)
4216    {
4217       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4218       return RFAILED;
4219    }
4220    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4221
4222    dlBwp->pdcch_Config->choice.setup = NULLP;
4223    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4224    if(!dlBwp->pdcch_Config->choice.setup)
4225    {
4226       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4227       return RFAILED;
4228    }
4229    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4230    {
4231       return RFAILED;
4232    }
4233
4234    dlBwp->pdsch_Config = NULLP;
4235    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4236    if(!dlBwp->pdsch_Config)
4237    {
4238       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4239       return RFAILED;
4240    }
4241    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4242
4243    dlBwp->pdsch_Config->choice.setup = NULLP;
4244    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4245    if(!dlBwp->pdsch_Config->choice.setup)
4246    {
4247       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4248       return RFAILED;
4249    }
4250
4251    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4252    {
4253       return RFAILED;
4254    }
4255
4256    dlBwp->sps_Config = NULLP;
4257    dlBwp->radioLinkMonitoringConfig = NULLP;
4258    return ROK;
4259 }
4260
4261 /*******************************************************************
4262  *
4263  * @brief Builds DMRS UL Pusch Mapping type A
4264  *
4265  * @details
4266  *
4267  *    Function : BuildDMRSULPuschMapTypeA
4268  *
4269  *    Functionality: Builds DMRS UL Pusch Mapping type A
4270  *
4271  * @params[in]
4272  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4273  * @return ROK     - success
4274  *         RFAILED - failure
4275  *
4276  * ****************************************************************/
4277 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4278 {
4279    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4280    dmrsUlCfg->choice.setup= NULLP;
4281    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4282    if(!dmrsUlCfg->choice.setup)
4283    {
4284       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4285       return RFAILED;
4286    }
4287
4288    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4289    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4290    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4291    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4292    {
4293       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4294       return RFAILED;
4295    }
4296    if(ulDmrsCfgDb == NULLP)
4297       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4298    else
4299       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4300
4301    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4302    dmrsUlCfg->choice.setup->maxLength = NULLP;
4303    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4304    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4305    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4306    {
4307       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4308       return RFAILED;
4309    }
4310
4311    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4312    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4313          sizeof(long));
4314    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4315    {
4316       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4317       return RFAILED;
4318    }
4319    if(ulDmrsCfgDb == NULLP)
4320       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4321    else
4322       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4323
4324    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4325    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4326    return ROK;
4327 }
4328
4329 /*******************************************************************
4330  *
4331  * @brief Build PUSCH time domain allocation list
4332  *
4333  * @details
4334  *
4335  *    Function : BuildPuschTimeDomAllocList
4336  *
4337  *    Functionality: Build PUSCH time domain allocation list
4338  *
4339  * @params[in]
4340  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4341  *
4342  * @return ROK     - success
4343  *         RFAILED - failure
4344  *
4345  * ****************************************************************/
4346 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4347 {
4348    uint8_t idx;
4349    uint8_t elementCnt;
4350    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4351
4352    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4353    timeDomAllocList->choice.setup = NULLP;
4354    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4355    if(!timeDomAllocList->choice.setup)
4356    {
4357       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4358       return RFAILED;
4359    }
4360
4361    if(puschCfgDb == NULLP)
4362       elementCnt = 2;
4363    else
4364       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4365
4366    timeDomAllocList->choice.setup->list.count = elementCnt;
4367    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4368    timeDomAllocList->choice.setup->list.array = NULLP;
4369    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4370    if(!timeDomAllocList->choice.setup->list.array)
4371    {
4372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4373       return RFAILED;
4374    }
4375
4376    for(idx = 0; idx < elementCnt; idx++)
4377    {
4378       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4379       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4380       if(!timeDomAllocList->choice.setup->list.array[idx])
4381       {
4382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4383          return RFAILED;
4384       }
4385    }
4386
4387    for(idx = 0; idx < elementCnt; idx++)
4388    {
4389       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4390       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4391       if(!timeDomAlloc->k2)
4392       {
4393          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4394          return RFAILED;
4395       }
4396       if(puschCfgDb == NULLP)
4397       {
4398          if(idx == 0)
4399             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4400          else if(idx == 1)
4401             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4402
4403          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4404          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4405       }
4406       else
4407       {
4408          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4409          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4410          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4411       }
4412    }
4413
4414    return ROK;
4415 }
4416
4417 /*******************************************************************
4418  *
4419  * @brief Builds BWP UL dedicated PUSCH Config
4420  *
4421  * @details
4422  *
4423  *    Function : BuildBWPUlDedPuschCfg
4424  *
4425  *    Functionality:
4426  *      Builds BWP UL dedicated PUSCH Config
4427  *
4428  * @params[in] : PUSCH_Config_t *puschCfg
4429  *
4430  * @return ROK     - success
4431  *         RFAILED - failure
4432  *
4433  * ****************************************************************/
4434 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4435 {
4436    DmrsUlCfg *ulDmrsCfg = NULLP;
4437
4438    if(puschCfgDb)
4439       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4440
4441    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4442    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4443    if(!puschCfg->dataScramblingIdentityPUSCH)
4444    {
4445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4446       return RFAILED;
4447    }
4448    if(puschCfgDb == NULLP)
4449       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4450    else
4451       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4452
4453    puschCfg->txConfig = NULLP;
4454    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4455    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4456    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4457    {
4458       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4459       return RFAILED;
4460    }
4461
4462    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4463    {
4464       return RFAILED;
4465    }
4466
4467    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4468    puschCfg->pusch_PowerControl = NULLP;
4469    puschCfg->frequencyHopping = NULLP;
4470    puschCfg->frequencyHoppingOffsetLists = NULLP;
4471
4472    if(puschCfgDb == NULLP)
4473       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4474    else
4475       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4476
4477    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4478    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4479    if(!puschCfg->pusch_TimeDomainAllocationList)
4480    {
4481       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4482       return RFAILED;
4483    }
4484
4485    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4486    {
4487       return RFAILED;
4488    }
4489
4490    puschCfg->pusch_AggregationFactor = NULLP;
4491    puschCfg->mcs_Table = NULLP;
4492    puschCfg->mcs_TableTransformPrecoder = NULLP;
4493    puschCfg->transformPrecoder = NULLP;
4494    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4495    if(!puschCfg->transformPrecoder)
4496    {
4497       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4498       return RFAILED;
4499    }
4500    if(puschCfgDb == NULLP)
4501       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4502    else
4503       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4504
4505    puschCfg->codebookSubset = NULLP;
4506    puschCfg->maxRank = NULLP;
4507    puschCfg->rbg_Size = NULLP;
4508    puschCfg->uci_OnPUSCH = NULLP;
4509    puschCfg->tp_pi2BPSK = NULLP;
4510
4511    return ROK;
4512 }
4513
4514 /*******************************************************************
4515  *
4516  * @brief Builds PUCCH resource set add/modify list
4517  *
4518  * @details
4519  *
4520  *    Function : BuildPucchRsrcSetAddModList
4521  *
4522  *    Functionality:
4523  *      Builds PUCCH resource set add/modify list
4524  *
4525  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4526  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4527  *
4528  * @return ROK     - success
4529  *         RFAILED - failure
4530  *
4531  * ****************************************************************/
4532 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4533    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4534 {
4535    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4536    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4537
4538    if(rsrcSetCfgDb == NULLP)
4539       elementCnt = 1;
4540    else
4541       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4542
4543    resourceSetToAddModList->list.count = elementCnt;
4544    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4545    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4546    if(resourceSetToAddModList->list.array == NULLP)
4547    {
4548       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4549       return RFAILED;
4550    }
4551    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4552    {
4553       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4554       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4555       {
4556          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4557          return RFAILED;
4558       }
4559    }
4560
4561    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4562    {
4563       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4564
4565       /* Resource set Id */
4566       if(rsrcSetCfgDb == NULLP)
4567          rsrcSet->pucch_ResourceSetId = 1;
4568       else
4569          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4570
4571       /* Resource list of a resource set */
4572       if(rsrcSetCfgDb == NULLP)
4573          elementCnt = 1;
4574       else
4575          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4576       rsrcSet->resourceList.list.count = elementCnt;
4577       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4578       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4579       if(rsrcSet->resourceList.list.array == NULLP)
4580       {
4581          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4582          return RFAILED;
4583       }
4584
4585       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4586       {
4587          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4588          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4589          {
4590             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4591             return RFAILED;
4592          }
4593       }
4594       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4595       {
4596          if(rsrcSetCfgDb == NULLP)
4597             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4598          else
4599             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4600       }
4601
4602       /* Max payload size (minus 1) in a Resource set */
4603       rsrcSet->maxPayloadMinus1 = NULLP;
4604       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4605       {
4606          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4607          if(rsrcSet->maxPayloadMinus1 == NULLP)
4608          {
4609             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4610             return RFAILED;
4611          }
4612          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4613       }
4614    }
4615    return ROK;
4616 }
4617
4618 /*******************************************************************
4619  *
4620  * @brief Builds PUCCH resource add/modify list
4621  *
4622  * @details
4623  *
4624  *    Function : BuildPucchRsrcAdddModList
4625  *
4626  *    Functionality:
4627  *      Builds PUCCH resource add/modify list
4628  *
4629  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4630  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4631  *
4632  * @return ROK     - success
4633  *         RFAILED - failure
4634  *
4635  * ****************************************************************/
4636 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4637 {
4638    uint8_t elementCnt = 0, rsrcIdx = 0;
4639    PUCCH_Resource_t *rsrc = NULLP;
4640
4641    if(rsrcCfgDb == NULLP)
4642       elementCnt = 1;
4643    else
4644       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4645    resourceToAddModList->list.count = elementCnt;
4646    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4647    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4648    if(resourceToAddModList->list.array == NULLP)
4649    {
4650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4651       return RFAILED;
4652    }
4653    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4654    {
4655       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4656       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4657       {
4658          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4659          return RFAILED;
4660       }
4661    }
4662
4663    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4664    {
4665       rsrc = resourceToAddModList->list.array[rsrcIdx];
4666
4667       if(rsrcCfgDb == NULLP)
4668       {
4669          rsrc->pucch_ResourceId = 1;
4670          rsrc->startingPRB = 0;
4671          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4672          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4673          if(rsrc->format.choice.format1 == NULLP)
4674          {
4675             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4676             return RFAILED;
4677          }
4678          rsrc->format.choice.format1->initialCyclicShift = 0;
4679          rsrc->format.choice.format1->nrofSymbols = 4;
4680          rsrc->format.choice.format1->startingSymbolIndex = 0;
4681          rsrc->format.choice.format1->timeDomainOCC = 0;
4682       }
4683       else
4684       {
4685          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4686          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4687          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4688          {
4689             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4690             if(rsrc->intraSlotFrequencyHopping == NULLP)
4691             {
4692                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4693                return RFAILED;
4694             }
4695             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4696          }
4697          else
4698             rsrc->intraSlotFrequencyHopping = NULLP;
4699
4700          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4701          {
4702             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4703             if(rsrc->secondHopPRB == NULLP)
4704             {
4705                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4706                return RFAILED;
4707             }
4708             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4709          }
4710          else
4711             rsrc->secondHopPRB = NULLP;
4712          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4713
4714          switch(rsrc->format.present)
4715          {
4716             case PUCCH_Resource__format_PR_NOTHING:
4717                break;
4718             case PUCCH_Resource__format_PR_format0:
4719                {
4720                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4721                   if(rsrc->format.choice.format0 == NULLP)
4722                   {
4723                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4724                      return RFAILED;
4725                   }
4726                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4727                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4728                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4729                   break;
4730                }
4731
4732             case PUCCH_Resource__format_PR_format1:
4733                {
4734                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4735                   if(rsrc->format.choice.format1 == NULLP)
4736                   {
4737                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4738                      return RFAILED;
4739                   }
4740                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4741                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4742                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4743                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4744                   break;
4745                }
4746
4747             case PUCCH_Resource__format_PR_format2:
4748                {
4749                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4750                   if(rsrc->format.choice.format2 == NULLP)
4751                   {
4752                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4753                      return RFAILED;
4754                   }
4755                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4756                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4757                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4758                   break;
4759                }
4760
4761             case PUCCH_Resource__format_PR_format3:
4762                {
4763                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4764                   if(rsrc->format.choice.format3 == NULLP)
4765                   {
4766                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4767                      return RFAILED;
4768                   }
4769                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4770                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4771                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4772                   break;
4773                }
4774
4775             case PUCCH_Resource__format_PR_format4:
4776                {
4777                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4778                   if(rsrc->format.choice.format4 == NULLP)
4779                   {
4780                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4781                      return RFAILED;
4782                   }
4783                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4784                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4785                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4786                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4787                   break;
4788                }
4789          }
4790       }
4791    }
4792    return ROK;
4793 }
4794
4795 /*******************************************************************
4796  *
4797  * @brief Builds PUCCH format  config
4798  *
4799  * @details
4800  *
4801  *    Function : BuildPucchFormat
4802  *
4803  *    Functionality: Builds PUCCH format  config
4804  *
4805  * @params[in] : PucchFormatCfg *formatDb
4806  *               PUCCH_FormatConfig_t *format
4807  *
4808  * @return ROK     - success
4809  *         RFAILED - failure
4810  *
4811  * ****************************************************************/
4812 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4813 {
4814    /* Inter Slot Fequency hopping */
4815    format->interslotFrequencyHopping = NULLP;
4816    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4817    {
4818       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4819       if(format->interslotFrequencyHopping)
4820       {
4821          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4822          return RFAILED;
4823       }
4824       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4825    }
4826
4827    /* Additional DMRS */
4828    format->additionalDMRS = NULLP;
4829    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4830    {
4831       DU_ALLOC(format->additionalDMRS, sizeof(long));
4832       if(format->additionalDMRS)
4833       {
4834          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4835          return RFAILED;
4836       }
4837       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4838    }
4839
4840     /* Maximum code rate */
4841    format->maxCodeRate = NULLP;
4842    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4843    {
4844       DU_ALLOC(format->maxCodeRate, sizeof(long));
4845       if(format->maxCodeRate)
4846       {
4847          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4848          return RFAILED;
4849       }
4850       *(format->maxCodeRate) = formatDb->maxCodeRate;
4851    }
4852
4853    /* Number of slots */
4854    format->nrofSlots = NULLP;
4855    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4856    {
4857       DU_ALLOC(format->nrofSlots, sizeof(long));
4858       if(format->nrofSlots == NULLP)
4859       {
4860          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4861          return RFAILED;
4862       }
4863       if(formatDb == NULLP)
4864          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4865       else
4866          *(format->nrofSlots) = formatDb->numSlots;
4867    }
4868
4869    /* Pi2BPSK*/
4870    format->pi2BPSK = NULLP;
4871    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4872    {
4873       DU_ALLOC(format->pi2BPSK, sizeof(long));
4874       if(format->pi2BPSK)
4875       {
4876          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4877          return RFAILED;
4878       }
4879       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4880    }
4881
4882    /* Simultaneous HARQ ACK and CSI */
4883    format->simultaneousHARQ_ACK_CSI = NULLP;
4884    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4885    {
4886       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4887       if(format->simultaneousHARQ_ACK_CSI)
4888       {
4889          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4890          return RFAILED;
4891       }
4892       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4893    }
4894
4895    return ROK;
4896 }
4897
4898
4899 /*******************************************************************
4900  *
4901  * @brief Builds PUCCH scheduling request list
4902  *
4903  * @details
4904  *
4905  *    Function : BuildPucchSchReqAddModList
4906  *
4907  *    Functionality:
4908  *      Builds PUCCH scheduling request list
4909  *
4910  * @params[in] : PucchSchedReqCfg *schReqDb
4911  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4912  *
4913  * @return ROK     - success
4914  *         RFAILED - failure
4915  *
4916  * ****************************************************************/
4917 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4918    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4919 {
4920    uint8_t elementCnt = 0, schReqIdx = 0;
4921    SchedulingRequestResourceConfig_t *schReqRsrc;
4922
4923    elementCnt = schReqDb->schedAddModListCount;
4924    schReqRsrcToAddModList->list.count = elementCnt;
4925    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4926
4927    schReqRsrcToAddModList->list.array = NULLP;
4928    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4929    if(schReqRsrcToAddModList->list.array == NULLP)
4930    {
4931       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4932       return RFAILED;
4933    }
4934
4935    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4936    {
4937       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4938       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4939       {
4940          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4941          return RFAILED;
4942       }
4943    }
4944
4945    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4946    {
4947       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
4948       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
4949       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
4950
4951       if(schReqDb->schedAddModList[schReqIdx].periodicity)
4952       {
4953          schReqRsrc->periodicityAndOffset = NULLP;
4954          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
4955          if(schReqRsrc->periodicityAndOffset == NULLP)
4956          {
4957             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4958             return RFAILED;
4959          }
4960
4961          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
4962          switch(schReqRsrc->periodicityAndOffset->present)
4963          {
4964             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
4965                break;
4966             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
4967                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
4968                break;
4969             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
4970                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
4971                break;
4972             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
4973                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
4974                break;
4975             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
4976                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
4977                break;
4978             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
4979                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
4980                break;
4981             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
4982                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
4983                break;
4984             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
4985                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
4986                break;
4987             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
4988                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
4989                break;
4990             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
4991                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
4992                break;
4993             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
4994                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
4995                break;
4996             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
4997                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
4998                break;
4999             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5000                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5001                break;
5002             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5003                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5004                break;
5005             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5006                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5007                break;
5008             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5009                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5010                break;
5011          }
5012       }
5013
5014       if(schReqDb->schedAddModList[schReqIdx].resrc)
5015       {
5016          schReqRsrc->resource = NULLP;
5017          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5018          if(schReqRsrc->resource == NULLP)
5019          {
5020             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5021             return RFAILED;
5022          }
5023          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5024
5025       }
5026    }
5027    return ROK;
5028 }
5029
5030 /*******************************************************************
5031  *
5032  * @brief Builds PUCCH multi csi resource list
5033  *
5034  * @details
5035  *
5036  *    Function : BuildPucchMultiCsiRsrcList
5037  *
5038  *    Functionality:
5039  *      Builds PUCCH multi csi resource list
5040  *
5041  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5042  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5043  *
5044  * @return ROK     - success
5045  *         RFAILED - failure
5046  *
5047  * ****************************************************************/
5048 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5049 {
5050    uint8_t elementCnt = 0, rsrcIdx = 0;
5051
5052    elementCnt = multiCsiDb->multiCsiResrcListCount;
5053    multiCsiRsrcList->list.count = elementCnt;
5054    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5055    multiCsiRsrcList->list.array = NULLP;
5056    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5057    if(multiCsiRsrcList->list.array == NULLP)
5058    {
5059       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5060       return RFAILED;
5061    }
5062
5063    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5064    {
5065       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5066       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5067       {
5068          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5069          return RFAILED;
5070       }
5071    }
5072
5073    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5074    {
5075       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5076    }
5077    return ROK;
5078 }
5079
5080 /*******************************************************************
5081  *
5082  * @brief Builds DL data -to- Ul Ack list
5083  *
5084  * @details
5085  *
5086  *    Function : BuildDlDataToUlAckList
5087  *
5088  *    Functionality: Builds DL data -to- Ul Ack list
5089  *
5090  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5091  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5092  *
5093  * @return ROK     - success
5094  *         RFAILED - failure
5095  *
5096  * ****************************************************************/
5097 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5098 {
5099    uint8_t elementCnt = 0, arrIdx = 0;
5100
5101    if(dlDataToUlAckDb == NULLP)
5102       elementCnt = 2;
5103    else
5104       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5105
5106    dlDataToUlACKList->list.count = elementCnt;
5107    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5108    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5109    if(dlDataToUlACKList->list.array == NULLP)
5110    {
5111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5112       return RFAILED;
5113    }
5114
5115    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5116    {
5117       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5118       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5119       {
5120          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5121          return RFAILED;
5122       }
5123    }
5124
5125    if(dlDataToUlAckDb == NULLP)
5126    {
5127       arrIdx = 0;
5128       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5129       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5130    }
5131    else
5132    {
5133       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5134       {
5135          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5136       }
5137    }
5138    return ROK;
5139 }
5140
5141 /*******************************************************************
5142  *
5143  * @brief Builds BWP UL dedicated PUCCH Config
5144  *
5145  * @details
5146  *
5147  *    Function : BuildBWPUlDedPucchCfg
5148  *
5149  *    Functionality:
5150  *      Builds BWP UL dedicated PUCCH Config
5151  *
5152  * @params[in] : PUCCH_Config_t *pucchCfg
5153  *
5154  * @return ROK     - success
5155  *         RFAILED - failure
5156  *
5157  * ****************************************************************/
5158 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5159 {
5160    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5161    PucchResrcCfg *rsrcCfgDb = NULLP;
5162    PucchFormatCfg *format1Db = NULLP;
5163    PucchFormatCfg *format2Db = NULLP;
5164    PucchFormatCfg *format3Db = NULLP;
5165    PucchFormatCfg *format4Db = NULLP;
5166    PucchSchedReqCfg *schReqDb = NULLP;
5167    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5168    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5169
5170    if(pucchCfgDb)
5171    {
5172       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5173       rsrcCfgDb = pucchCfgDb->resrc;
5174       format1Db = pucchCfgDb->format1;
5175       format2Db = pucchCfgDb->format2;
5176       format3Db = pucchCfgDb->format3;
5177       format4Db = pucchCfgDb->format4;
5178       schReqDb = pucchCfgDb->schedReq;
5179       multiCsiDb = pucchCfgDb->multiCsiCfg;
5180       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5181    }
5182
5183    /* RESOURCE SET */
5184    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5185    if(pucchCfg->resourceSetToAddModList == NULL)
5186    {
5187       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5188       return RFAILED;
5189    }
5190
5191    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5192    {
5193       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5194       return RFAILED;
5195    }
5196
5197    /* PUCCH RESOURCE */
5198    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5199    if(pucchCfg->resourceToAddModList == NULLP)
5200    {
5201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5202       return RFAILED;
5203    }
5204
5205    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5206    {
5207       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5208       return RFAILED;
5209    }
5210
5211    /* PUCCH Format 1 */
5212    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5213    if(pucchCfg->format1 == NULLP)
5214    {
5215       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5216       return RFAILED;
5217    }
5218
5219    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5220    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5221    if(pucchCfg->format1->choice.setup == NULLP)
5222    {
5223       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5224       return RFAILED;
5225    }
5226
5227    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5228    {
5229       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5230       return RFAILED;
5231    }
5232
5233    /* PUCCH Format 2 */
5234    if(format2Db)
5235    {
5236       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5237       if(pucchCfg->format2 == NULLP)
5238       {
5239          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5240          return RFAILED;
5241       }
5242
5243       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5244       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5245       if(pucchCfg->format2->choice.setup == NULLP)
5246       {
5247          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5248          return RFAILED;
5249       }
5250
5251       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5252       {
5253          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5254          return RFAILED;
5255       }
5256    }
5257
5258    /* PUCCH Format 3 */
5259    if(format3Db)
5260    {
5261       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5262       if(pucchCfg->format3 == NULLP)
5263       {
5264          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5265          return RFAILED;
5266       }
5267
5268       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5269       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5270       if(pucchCfg->format3->choice.setup == NULLP)
5271       {
5272          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5273          return RFAILED;
5274       }
5275
5276       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5277       {
5278          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5279          return RFAILED;
5280       }
5281    }
5282
5283    /* PUCCH Format 4 */
5284    if(format4Db)
5285    {
5286       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5287       if(pucchCfg->format4 == NULLP)
5288       {
5289          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5290          return RFAILED;
5291       }
5292
5293       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5294       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5295       if(pucchCfg->format4->choice.setup == NULLP)
5296       {
5297          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5298          return RFAILED;
5299       }
5300
5301       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5302       {
5303          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5304          return RFAILED;
5305       }
5306    }
5307
5308    /* Scheduling Request */
5309    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5310    {
5311       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5312       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5313       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5314       {
5315          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5316          return RFAILED;
5317       }
5318
5319       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5320       {
5321          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5322          return RFAILED;
5323       }
5324    }
5325
5326    /* Multi CSI */
5327    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5328    {
5329       pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
5330       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5331       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5332       {
5333          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5334          return RFAILED;
5335       }
5336
5337       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5338       {
5339          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5340          return RFAILED;
5341       }
5342    }
5343
5344    /* DL DATA TO UL ACK */
5345    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5346    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5347    {
5348       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5349       return RFAILED;
5350    }
5351
5352    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5353    {
5354       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5355       return RFAILED;
5356    }
5357
5358    /* TODO : spatial relation info add/mod list and power control*/
5359
5360    return ROK;
5361 }
5362
5363 /*******************************************************************
5364  *
5365  * @brief Fills SRS resource to add/modify list
5366  *
5367  * @details
5368  *
5369  *    Function : BuildSrsRsrcAddModList
5370  *
5371  *    Functionality: Fills SRS resource to add/modify list
5372  *
5373  * @params[in]
5374  * @return ROK     - success
5375  *         RFAILED - failure
5376  *
5377  * ****************************************************************/
5378 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5379 {
5380    uint8_t   elementCnt;
5381    uint8_t   rsrcIdx;
5382
5383    elementCnt = 1;
5384    resourceList->list.count = elementCnt;
5385    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5386    resourceList->list.array = NULLP;
5387    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5388    if(!resourceList->list.array)
5389    {
5390       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5391       return RFAILED;
5392    }
5393
5394    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5395    {
5396       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5397       if(!resourceList->list.array[rsrcIdx])
5398       {
5399          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5400          return RFAILED;
5401       }
5402    }
5403
5404    rsrcIdx = 0;
5405    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5406    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5407    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5408
5409    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5410    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5411          sizeof(struct SRS_Resource__transmissionComb__n2));
5412    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5413    {
5414       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5415       return RFAILED;
5416    }
5417    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5418       = SRS_COMB_OFFSET_N2;
5419    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5420       = SRS_CYCLIC_SHIFT_N2;
5421
5422    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5423                                                                       PUSCH_START_SYMBOL;
5424    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5425                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5426    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5427                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5428
5429    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5430    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5431    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5432    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5433    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5434    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5435                                                                SRS_Resource__groupOrSequenceHopping_neither;
5436
5437    /* Setting resource type to aperiodic for intergration purposes */
5438    resourceList->list.array[rsrcIdx]->resourceType.present = \
5439                                                              SRS_Resource__resourceType_PR_aperiodic;
5440    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5441    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5442          sizeof(struct SRS_Resource__resourceType__aperiodic));
5443    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5444    {
5445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5446       return RFAILED;
5447    }
5448    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5449
5450    return ROK;
5451 }
5452
5453 /*******************************************************************
5454  *
5455  * @brief Build SRS resource set Add/mod list
5456  *
5457  * @details
5458  *
5459  *    Function : BuildSrsRsrcSetAddModList
5460  *
5461  *    Functionality: Build SRS resource set Add/mod list
5462  *
5463  * @params[in]
5464  * @return ROK     - success
5465  *         RFAILED - failure
5466  *
5467  * ****************************************************************/
5468    uint8_t BuildSrsRsrcSetAddModList
5469 (
5470  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5471  )
5472 {
5473    uint8_t  elementCnt;
5474    uint8_t  rSetIdx;
5475    uint8_t  rsrcIdx;
5476    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5477
5478    elementCnt = 1;
5479    rsrcSetList->list.count = elementCnt;
5480    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5481    rsrcSetList->list.array = NULLP;
5482    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5483    if(!rsrcSetList->list.array)
5484    {
5485       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5486       return RFAILED;
5487    }
5488
5489    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5490    {
5491       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5492       if(!rsrcSetList->list.array[rSetIdx])
5493       {
5494          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5495          return RFAILED;
5496       }
5497    }
5498
5499    rSetIdx = 0;
5500    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5501
5502    /* Fill Resource Id list in resource set */
5503    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5504    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5505          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5506    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5507    {
5508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5509       return RFAILED;
5510    }
5511
5512    elementCnt = 1;
5513    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5514    rsrcIdList->list.count = elementCnt;
5515    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5516    rsrcIdList->list.array = NULLP;
5517    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5518    if(!rsrcIdList->list.array)
5519    {
5520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5521       return RFAILED;
5522    }
5523
5524    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5525    {
5526       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5527       if(!rsrcIdList->list.array[rsrcIdx])
5528       {
5529          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5530          return RFAILED;
5531       }
5532    }
5533
5534    rsrcIdx = 0;
5535    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5536
5537    /* Fill resource type */
5538    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5539                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5540
5541    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5542    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5543          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5544    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5545    {
5546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5547       return RFAILED;
5548    }
5549    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5550       = APERIODIC_SRS_RESRC_TRIGGER;
5551
5552    /* TODO : Fill values for below IEs as expected by Viavi */
5553    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5554    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5555
5556
5557    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5558    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5559    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5560    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5561    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5562
5563    return ROK;
5564 }
5565
5566 /*******************************************************************
5567  *
5568  * @brief Builds BWP UL dedicated SRS Config
5569  *
5570  * @details
5571  *
5572  *    Function : BuildBWPUlDedSrsCfg
5573  *
5574  *    Functionality: Builds BWP UL dedicated SRS Config
5575  *
5576  * @params[in] SRS Config
5577  * @return ROK     - success
5578  *         RFAILED - failure
5579  *
5580  * ****************************************************************/
5581 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5582 {
5583    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5584    srsCfg->srs_ResourceSetToAddModList = NULLP;
5585    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5586          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5587    if(!srsCfg->srs_ResourceSetToAddModList)
5588    {
5589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5590       return RFAILED;
5591    }
5592    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5593    {
5594       return RFAILED;
5595    }
5596
5597    srsCfg->srs_ResourceToReleaseList = NULLP;
5598
5599    /* Resource to Add/Modify list */
5600    srsCfg->srs_ResourceToAddModList = NULLP;
5601    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5602          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5603    if(!srsCfg->srs_ResourceToAddModList)
5604    {
5605       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5606       return RFAILED;
5607    }
5608
5609    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5610    {
5611       return RFAILED;
5612    }
5613
5614    srsCfg->tpc_Accumulation = NULLP;
5615
5616    return ROK;
5617 }
5618
5619
5620
5621 /*******************************************************************
5622  *
5623  * @brief Builds Pusch Serving cell Config
5624  *
5625  * @details
5626  *
5627  *    Function : BuildPuschSrvCellCfg
5628  *
5629  *    Functionality: Builds Pusch Serving cell Config
5630  *
5631  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5632  *
5633  * @return ROK     - success
5634  *         RFAILED - failure
5635  *
5636  * ****************************************************************/
5637 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5638 {
5639    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5640    puschCfg->choice.setup = NULLP;
5641    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5642    if(!puschCfg->choice.setup)
5643    {
5644       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5645       return RFAILED;
5646    }
5647
5648    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5649    puschCfg->choice.setup->rateMatching = NULLP;
5650    puschCfg->choice.setup->xOverhead = NULLP;
5651    puschCfg->choice.setup->ext1 = NULLP;
5652    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5653    if(!puschCfg->choice.setup->ext1)
5654    {
5655       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5656       return RFAILED;
5657    }
5658
5659    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5660    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5661    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5662    {
5663       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5664       return RFAILED;
5665    }
5666    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5667
5668    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5669    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5670    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5671    {
5672       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5673       return RFAILED;
5674    }
5675    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5676    return ROK;
5677 }
5678
5679 /*******************************************************************
5680  *
5681  * @brief Builds inital UL BWP
5682  *
5683  * @details
5684  *
5685  *    Function : BuildInitialUlBWP
5686  *
5687  *    Functionality: Builds initial UL BWP
5688  *
5689  * @params[in] BWP_UplinkDedicated_t *ulBwp
5690  * @return ROK     - success
5691  *         RFAILED - failure
5692  *
5693  * ****************************************************************/
5694 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5695 {
5696    PucchCfg *pucchCfg = NULLP;
5697    PuschCfg *puschCfg = NULLP;
5698
5699    if(initUlBwp)
5700    {
5701       if(initUlBwp->pucchPresent)
5702          pucchCfg = &initUlBwp->pucchCfg;
5703       if(initUlBwp->puschPresent)
5704          puschCfg = &initUlBwp->puschCfg;
5705    }
5706
5707    ulBwp->pucch_Config = NULLP;
5708    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5709    if(!ulBwp->pucch_Config)
5710    {
5711       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5712       return RFAILED;
5713    }
5714
5715    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5716    ulBwp->pucch_Config->choice.setup = NULLP;
5717    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5718    if(!ulBwp->pucch_Config->choice.setup)
5719    {
5720       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5721       return RFAILED;
5722    }
5723
5724    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5725    {
5726       return RFAILED;
5727    }
5728
5729    /* Fill BWP UL dedicated PUSCH config */
5730    ulBwp->pusch_Config = NULLP;
5731    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5732    if(!ulBwp->pusch_Config)
5733    {
5734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5735       return RFAILED;
5736    }
5737
5738    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5739    ulBwp->pusch_Config->choice.setup = NULLP;
5740    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5741    if(!ulBwp->pusch_Config->choice.setup)
5742    {
5743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5744       return RFAILED;
5745    }
5746
5747    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5748    {
5749       return RFAILED;
5750    }
5751
5752    ulBwp->configuredGrantConfig = NULLP;
5753
5754    /* Fill BPW UL dedicated SRS config */
5755    ulBwp->srs_Config = NULLP;
5756    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5757    if(!ulBwp->srs_Config)
5758    {
5759       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5760       return RFAILED;
5761    }
5762
5763    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5764    ulBwp->srs_Config->choice.setup = NULLP;
5765    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5766    if(!ulBwp->srs_Config->choice.setup)
5767    {
5768       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5769       return RFAILED;
5770    }
5771
5772    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5773    {
5774       return RFAILED;
5775    }
5776
5777    ulBwp->beamFailureRecoveryConfig = NULLP;
5778
5779    return ROK;
5780 }
5781
5782 /*******************************************************************
5783  *
5784  * @brief Builds UL config
5785  * @details
5786  *
5787  *    Function : BuildUlCfg
5788  *
5789  *    Functionality: Builds UL config in spCellCfgDed
5790  *
5791  * @params[in] UplinkConfig_t *ulCfg
5792  *
5793  * @return ROK     - success
5794  *         RFAILED - failure
5795  *
5796  * ****************************************************************/
5797 uint8_t BuildUlCfg(ServCellCfgInfo *servCellCfg, UplinkConfig_t *ulCfg)
5798 {
5799    InitialUlBwp *initUlBwp = NULLP;
5800
5801    if(servCellCfg)
5802    {
5803       initUlBwp = &servCellCfg->initUlBwp;
5804    }
5805
5806    ulCfg->initialUplinkBWP = NULLP;
5807    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5808    if(!ulCfg->initialUplinkBWP)
5809    {
5810       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5811       return RFAILED;
5812    }
5813
5814    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5815    {
5816       return RFAILED;
5817    }
5818
5819    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5820    ulCfg->uplinkBWP_ToAddModList = NULLP;
5821    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5822    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5823    if(!ulCfg->firstActiveUplinkBWP_Id)
5824    {
5825       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5826       return RFAILED;
5827    }
5828    if(servCellCfg == NULLP)
5829       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5830    else
5831       *(ulCfg->firstActiveUplinkBWP_Id) = servCellCfg->firstActvUlBwpId;
5832
5833    ulCfg->pusch_ServingCellConfig = NULLP;
5834    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5835    if(!ulCfg->pusch_ServingCellConfig)
5836    {
5837       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5838       return RFAILED;
5839    }
5840
5841    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5842    {
5843       return RFAILED;
5844    }
5845
5846    ulCfg->carrierSwitching = NULLP;
5847    ulCfg->ext1 = NULLP;
5848    return ROK;
5849 }
5850
5851 /*******************************************************************
5852  *
5853  * @brief Builds PDSCH serving cell config
5854  * @details
5855  *
5856  *    Function : BuildPdschSrvCellCfg
5857  *
5858  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5859  *
5860  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5861  *
5862  * @return ROK     - success
5863  *         RFAILED - failure
5864  *
5865  * ****************************************************************/
5866 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5867 {
5868    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5869    pdschCfg->choice.setup = NULLP;
5870    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5871    if(!pdschCfg->choice.setup)
5872    {
5873       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5874       return RFAILED;
5875    }
5876
5877    /* Code Block Group Transmission */
5878    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5879    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5880    {
5881       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5882       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5883       {
5884          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5885          return RFAILED;
5886       }
5887
5888       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5889       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5890       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5891       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5892       {
5893          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5894          return RFAILED;
5895       }
5896
5897       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5898          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5899       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5900          *(pdschServCellDb->codeBlkGrpFlushInd);
5901    }
5902
5903    /* xOverhead */
5904    pdschCfg->choice.setup->xOverhead = NULLP;
5905    if(pdschServCellDb && pdschServCellDb->xOverhead)
5906    {
5907       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5908       if(pdschCfg->choice.setup->xOverhead == NULLP)
5909       {
5910          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5911          return RFAILED;
5912       }
5913       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5914    }
5915
5916    /* Number of HARQ processes */
5917    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5918    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5919    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5920    {
5921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5922       return RFAILED;
5923    }
5924
5925    if(pdschServCellDb == NULLP)
5926    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5927    else
5928    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5929
5930    pdschCfg->choice.setup->pucch_Cell = NULLP;
5931
5932    /* Extension */
5933    pdschCfg->choice.setup->ext1 = NULLP;
5934    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5935    {
5936       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5937       if(pdschCfg->choice.setup->ext1 == NULLP)
5938       {
5939          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5940          return RFAILED;
5941       }
5942
5943       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5944       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
5945       {
5946          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5947          return RFAILED;
5948       }
5949       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
5950    }
5951
5952    return ROK;
5953 }
5954
5955 /*******************************************************************
5956  *
5957  * @brief Builds CSI Meas config
5958  * @details
5959  *
5960  *    Function : BuildCsiMeasCfg
5961  *
5962  *    Functionality: Builds CSI Meas config in spCellCfgDed
5963  *
5964  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5965  *
5966  * @return ROK     - success
5967  *         RFAILED - failure
5968  *
5969  * ****************************************************************/
5970 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5971 {
5972
5973    return ROK;
5974 }
5975
5976 /*******************************************************************
5977  *
5978  * @brief Builds DL BWP to add/modify list
5979  * @details
5980  *
5981  *    Function : BuildDlBwpToAddModList
5982  *
5983  *    Functionality: Builds DL BWP to add/modify list
5984  *
5985  * @params[in] ServCellCfgInfo *servCellCfg,
5986  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
5987  *
5988  * @return ROK     - success
5989  *         RFAILED - failure
5990  *
5991  * ****************************************************************/
5992 uint8_t BuildDlBwpToAddModList(ServCellCfgInfo *servCellCfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
5993 {
5994    uint8_t elementCnt, idx;
5995
5996    elementCnt = servCellCfg->numDlBwpToAdd;
5997    dlBwpAddModList->list.count = elementCnt;
5998    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
5999    dlBwpAddModList->list.array = NULLP;
6000    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6001    if(dlBwpAddModList->list.array == NULLP)
6002    {
6003       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6004       return RFAILED;
6005    }
6006
6007    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6008    {
6009       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6010       if(dlBwpAddModList->list.array[idx] == NULLP)
6011       {
6012          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6013          return RFAILED;
6014       }
6015    }
6016
6017    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6018    {
6019       dlBwpAddModList->list.array[idx]->bwp_Id = servCellCfg->DlBwpToAddList[idx].bwpId;
6020       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6021       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6022    }
6023    return ROK;
6024 }
6025
6026 /*******************************************************************
6027  *
6028  * @brief Builds Spcell config dedicated
6029  * @details
6030  *
6031  *    Function : BuildSpCellCfgDed
6032  *
6033  *    Functionality: Builds sp cell config dedicated in spCellCfg
6034  *
6035  * @params[in] ServingCellConfig_t srvCellCfg
6036  *
6037  * @return ROK     - success
6038  *         RFAILED - failure
6039  *
6040  * ****************************************************************/
6041 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6042 {
6043    ServCellCfgInfo *servCellCfg = NULLP;
6044    InitialDlBwp *initDlBwp = NULLP;
6045    PdschServCellCfg *pdschServCellDb = NULLP;
6046
6047    if(ueCb)
6048    {
6049       servCellCfg = &ueCb->macUeCfg.spCellCfg.servCellCfg;
6050       initDlBwp = &servCellCfg->initDlBwp;
6051       pdschServCellDb = &servCellCfg->pdschServCellCfg;
6052    }
6053
6054    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6055    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6056    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6057    {
6058       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6059       return RFAILED;
6060    }
6061
6062    srvCellCfg->initialDownlinkBWP = NULLP;
6063    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6064    if(!srvCellCfg->initialDownlinkBWP)
6065    {
6066       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6067       return RFAILED;
6068    }
6069
6070    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6071    {
6072       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6073       return RFAILED;
6074    }
6075
6076    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6077
6078    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6079    if(ueCb && ueCb->macUeCfg.spCellCfg.servCellCfg.numDlBwpToAdd)
6080    {
6081       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6082       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6083       {
6084          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6085          return RFAILED;
6086       }
6087
6088       if(BuildDlBwpToAddModList(&ueCb->macUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6089       {
6090          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6091          return RFAILED;
6092       }
6093    }
6094
6095    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6096    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6097    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6098    {
6099       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6100       return RFAILED;
6101    }
6102    if(ueCb == NULLP)
6103       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6104    else
6105       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6106
6107    srvCellCfg->bwp_InactivityTimer = NULLP;
6108
6109    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6110    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6111    if(!srvCellCfg->defaultDownlinkBWP_Id)
6112    {
6113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6114       return RFAILED;
6115    }
6116    if(ueCb == NULLP)
6117       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6118    else
6119       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6120
6121    srvCellCfg->uplinkConfig = NULLP;
6122    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6123    if(!srvCellCfg->uplinkConfig)
6124    {
6125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6126       return RFAILED;
6127    }
6128
6129    if(BuildUlCfg(servCellCfg, srvCellCfg->uplinkConfig) != ROK)
6130    {
6131       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6132       return RFAILED;
6133    }
6134    srvCellCfg->supplementaryUplink = NULLP;
6135    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6136
6137    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6138    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6139    if(!srvCellCfg->pdsch_ServingCellConfig)
6140    {
6141       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6142       return RFAILED;
6143    }
6144
6145    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6146    {
6147       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6148       return RFAILED;
6149    }
6150
6151    srvCellCfg->csi_MeasConfig = NULLP;
6152 #if 0
6153    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6154       if(!srvCellCfg->csi_MeasConfig)
6155       {
6156          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6157          return RFAILED;
6158       }
6159
6160    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6161    {
6162       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6163       return RFAILED;
6164    }
6165 #endif
6166    srvCellCfg->sCellDeactivationTimer = NULLP;
6167    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6168    srvCellCfg->tag_Id = TAG_ID;
6169    srvCellCfg->dummy = NULLP;
6170    srvCellCfg->pathlossReferenceLinking = NULLP;
6171    srvCellCfg->servingCellMO = NULLP;
6172    srvCellCfg->ext1 = NULLP;
6173
6174    return ROK;
6175 }
6176
6177 /*******************************************************************
6178  *
6179  * @brief Fills SCS specific carrier list in DL frequency info
6180  *
6181  * @details
6182  *
6183  *    Function : BuildScsSpecificCarrierListDl
6184  *
6185  *    Functionality: Fills SCS specific carrier list in DL frequency info
6186  *
6187  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
6188  *
6189  * @return ROK     - success
6190  *         RFAILED - failure
6191  *
6192  * ****************************************************************/
6193 uint8_t BuildScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
6194 {
6195    uint8_t elementCnt = 0, listIdx = 0;
6196    ScsSpecCarrier duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.dlScsCarrier;
6197
6198    elementCnt = ODU_VALUE_ONE;
6199    scsCarrierList->list.count = elementCnt;
6200    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6201
6202    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6203    if(!scsCarrierList->list.array)
6204    {
6205       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for scs carrier list array \
6206          in BuildScsSpecificCarrierListDl()");
6207       return RFAILED;
6208    }
6209
6210    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6211    {
6212       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6213       if(!scsCarrierList->list.array[listIdx])
6214       {
6215          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SCS Specific Carrier list array \
6216             element in BuildScsSpecificCarrierListDl()");
6217          return RFAILED;
6218       }
6219    }
6220
6221    listIdx = 0;
6222    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6223    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6224    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6225
6226    return ROK;
6227 }
6228
6229 /*******************************************************************
6230  *
6231  * @brief Fills DL frequency info in DL config common
6232  *
6233  * @details
6234  *
6235  *    Function : BuildFreqInfoDl
6236  *
6237  *    Functionality: Fills DL frequency info in DL config common
6238  *
6239  * @params[in] Pointer to DownlinkConfigCommon_t
6240  *
6241  * @return ROK     - success
6242  *         RFAILED - failure
6243  *
6244  * ****************************************************************/
6245 uint8_t BuildFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
6246 {
6247    uint8_t freqBandIdx = 0, elementCnt = 0;
6248    DlCfgCommon  dlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg;
6249
6250    /* TODO : Fill SSB Absolute Frequency */
6251    /*
6252       DU_ALLOC(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
6253       if(!frequencyInfoDL->absoluteFrequencySSB)
6254       {
6255       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
6256       return RFAILED;
6257       }
6258       frequencyInfoDL->absoluteFrequencySSB = ?;
6259       */
6260
6261    /* NR Multi Frequency Band List */
6262    elementCnt = ODU_VALUE_ONE;
6263    frequencyInfoDL->frequencyBandList.list.count = elementCnt;
6264    frequencyInfoDL->frequencyBandList.list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6265
6266    DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
6267    if(!frequencyInfoDL->frequencyBandList.list.array)
6268    {
6269       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
6270       return RFAILED;
6271    }
6272
6273    for(freqBandIdx = 0; freqBandIdx < elementCnt; freqBandIdx++)
6274    {
6275       DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
6276       if(!frequencyInfoDL->frequencyBandList.list.array[freqBandIdx])
6277       {
6278          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
6279          return RFAILED;
6280       }
6281    }
6282
6283    freqBandIdx = 0;
6284    *(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx]) = dlCfg.freqBandInd;
6285
6286    /* TODO : Absolute Frequency to Point A */
6287    //frequencyInfoDL->absoluteFrequencyPointA
6288
6289    /* Subcarrier Spacing specifc carrier List */
6290    if((BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList)) != ROK)
6291    {
6292       DU_LOG("\nERROR  -->  DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
6293       return RFAILED;
6294    }
6295
6296    return ROK;
6297
6298 }
6299
6300 /*******************************************************************
6301  *
6302  * @brief Fills DL config common in Serving cell config common
6303  *
6304  * @details
6305  *
6306  *    Function : BuildDlConfigCommon
6307  *
6308  *    Functionality: Fills DL config common in Serving cell config common
6309  *
6310  * @params[in] Pointer to DownlinkConfigCommon_t
6311  *
6312  * @return ROK     - success
6313  *         RFAILED - failure
6314  *
6315  * ****************************************************************/
6316 uint8_t BuildDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
6317 {
6318    /* DL Frequency Info */
6319    DU_ALLOC(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
6320    if(!dlCfgCommon->frequencyInfoDL)
6321    {
6322       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
6323       return RFAILED;
6324    }
6325    if((BuildFreqInfoDl(dlCfgCommon->frequencyInfoDL))!= ROK)
6326    {
6327       DU_LOG("\nERROR  --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
6328       return RFAILED;
6329    }
6330
6331    /* DL BWP config common */
6332    DU_ALLOC(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
6333    if(!dlCfgCommon->initialDownlinkBWP)
6334    {
6335       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
6336       return RFAILED;
6337    }
6338    if((BuildBwpDlCommon(dlCfgCommon->initialDownlinkBWP)) != ROK)
6339    {
6340       DU_LOG("\nERROR  --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
6341       return RFAILED;
6342    }
6343
6344    return ROK;
6345 }
6346
6347 /*******************************************************************
6348  *
6349  * @brief Fills SCS specific carrier list in UL frequency Info
6350  *
6351  * @details
6352  *
6353  *    Function : BuildScsSpecificCarrierListUl
6354  *
6355  *    Functionality: Fills SCS specific carrier list in UL frequency Info
6356  *
6357  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
6358  *
6359  * @return ROK     - success
6360  *         RFAILED - failure
6361  *
6362  * ****************************************************************/
6363 uint8_t BuildScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
6364 {
6365    uint8_t elementCnt = 0, listIdx = 0;
6366    ScsSpecCarrier   duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.ulScsCarrier;
6367
6368    elementCnt = ODU_VALUE_ONE;
6369    scsCarrierList->list.count = elementCnt;
6370    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6371
6372    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6373    if(!scsCarrierList->list.array)
6374    {
6375       DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6376       return RFAILED;
6377    }
6378
6379    for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
6380    {
6381       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6382       if(!scsCarrierList->list.array[listIdx])
6383       {
6384          DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6385          return RFAILED;
6386       }
6387    }
6388    listIdx = 0;
6389    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6390    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6391    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6392
6393    return ROK;
6394 }
6395
6396 /*******************************************************************
6397  *
6398  * @brief Fills frequency info in UL config common
6399  *
6400  * @details
6401  *
6402  *    Function : BuildFreqInfoUl
6403  *
6404  *    Functionality: Fills frequency info in UL config common
6405  *
6406  * @params[in] Pointer to FrequencyInfoUL_t
6407  *
6408  * @return ROK     - success
6409  *         RFAILED - failure
6410  *
6411  * ****************************************************************/
6412 uint8_t BuildFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
6413 {
6414    uint8_t elementCnt = 0, listIdx= 0;
6415    UlCfgCommon  ulCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
6416
6417    /* NR Multi Frequency Band List */
6418    DU_ALLOC(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
6419    if(!frequencyInfoUL->frequencyBandList)
6420    {
6421       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
6422       return RFAILED;
6423    }
6424
6425    elementCnt = ODU_VALUE_ONE;
6426    frequencyInfoUL->frequencyBandList->list.count = elementCnt;
6427    frequencyInfoUL->frequencyBandList->list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6428
6429    DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
6430    if(!frequencyInfoUL->frequencyBandList->list.array)
6431    {
6432       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
6433       return RFAILED;
6434    }
6435
6436    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6437    {
6438       DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
6439       if(!frequencyInfoUL->frequencyBandList->list.array[listIdx])
6440       {
6441          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
6442          return RFAILED;
6443       }
6444    }
6445
6446    listIdx = 0;
6447    *(frequencyInfoUL->frequencyBandList->list.array[listIdx]) = ulCfg.freqBandInd;
6448
6449    /* TODO : Fill Absolute frequency point A */
6450    /*
6451       DU_ALLOC(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
6452       if(!frequencyInfoUL->absoluteFrequencyPointA)
6453       {
6454       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
6455       return RFAILED;
6456       }
6457     *(frequencyInfoUL->absoluteFrequencyPointA) = ?;
6458     */
6459
6460    /* Subcarrier Spacing specifc carrier */
6461    if((BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList)) != ROK)
6462    {
6463       DU_LOG("\nERROR  --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
6464       return RFAILED;
6465    }
6466
6467    /* P-MAX */
6468    DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
6469    if(!frequencyInfoUL->p_Max)
6470    {
6471       DU_LOG("\nERROR  -->  DU APP : UL Frequency Infoo  memory allocation failure");
6472       return RFAILED;
6473    }
6474    *frequencyInfoUL->p_Max = ulCfg.pMax;
6475
6476    return ROK;
6477 }
6478
6479 /*******************************************************************
6480  *
6481  * @brief Fills UL config common in Serving cell config common
6482  *
6483  * @details
6484  *
6485  *    Function : BuildUlConfigCommon
6486  *
6487  *    Functionality: Fills UL config common in Serving cell config common
6488  *
6489  * @params[in] Pointer to UplinkConfigCommon_t
6490  *
6491  * @return ROK     - success
6492  *         RFAILED - failure
6493  *
6494  * ****************************************************************/
6495 uint8_t BuildUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
6496 {
6497    /* UL Frequency Info */
6498    DU_ALLOC(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
6499    if(!ulCfgCommon->frequencyInfoUL)
6500    {
6501       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
6502       return RFAILED;
6503    }
6504
6505    if((BuildFreqInfoUl(ulCfgCommon->frequencyInfoUL)) != ROK)
6506    {
6507       DU_LOG("\nERROR  -->  DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
6508       return RFAILED;
6509    }
6510
6511    /* UL BWP common */
6512    DU_ALLOC(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
6513    if(!ulCfgCommon->initialUplinkBWP)
6514    {
6515       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
6516       return RFAILED;
6517    }
6518
6519    if((BuildBwpUlCommon(ulCfgCommon->initialUplinkBWP)) != ROK)
6520    {
6521       DU_LOG("\nERROR  -->  DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
6522       return RFAILED;
6523    }
6524
6525    /* Time Alignment timer */
6526    ulCfgCommon->dummy = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
6527
6528    return ROK;
6529 }
6530
6531 /*******************************************************************
6532  *
6533  * @brief Fills SSB position in burst in SP cell config common
6534  *
6535  * @details
6536  *
6537  *    Function : BuildSsbPosInBurst
6538  *
6539  *    Functionality:
6540  *       Fills SSB position in burst in SP cell config common
6541  *
6542  * @params[in] Pointer to struct ServingCellConfigCommon__ssb_PositionsInBurst
6543  *
6544  * @return ROK     - success
6545  *         RFAILED - failure
6546  *
6547  * ****************************************************************/
6548 uint8_t BuildSsbPosInBurst(struct ServingCellConfigCommon__ssb_PositionsInBurst *ssbPosInBurst)
6549 {
6550    uint8_t bitStringSizeInBytes = 0;
6551
6552    ssbPosInBurst->present = ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap;
6553
6554    /* As per spec 38.331,in the definition of ServingCellConfigCommon */
6555    bitStringSizeInBytes = 1;
6556    ssbPosInBurst->choice.mediumBitmap.size = bitStringSizeInBytes * sizeof(uint8_t);
6557
6558    DU_ALLOC(ssbPosInBurst->choice.mediumBitmap.buf, ssbPosInBurst->choice.mediumBitmap.size);
6559    if(!ssbPosInBurst->choice.mediumBitmap.buf)
6560    {
6561       DU_LOG("\nERROR  -->  DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
6562       return RFAILED;
6563    }
6564
6565    if((fillBitString(&ssbPosInBurst->choice.mediumBitmap, 0, bitStringSizeInBytes, \
6566                duCfgParam.sib1Params.srvCellCfgCommSib.ssbPosInBurst)) != ROK)
6567    {
6568       DU_LOG("\nERROR  -->  DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
6569       return RFAILED;
6570    }
6571
6572    return ROK;
6573 }
6574
6575 /*******************************************************************
6576  *
6577  * @brief Fills SP cell config common in Reconfig with Sync
6578  *
6579  * @details
6580  *
6581  *    Function : BuildSpCellConfigCommon
6582  *
6583  *    Functionality: Fills SP cell config common in Reconfig with Sync
6584  *
6585  * @params[in] Pointer to ServingCellConfigCommon_t
6586  *
6587  * @return ROK     - success
6588  *         RFAILED - failure
6589  *
6590  * ****************************************************************/
6591 uint8_t BuildSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
6592 {
6593    /* Physical Cell Identity */
6594    DU_ALLOC(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
6595    if(!spCellConfigCommon->physCellId)
6596    {
6597       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
6598       return RFAILED;
6599    }
6600    *(spCellConfigCommon->physCellId) = NR_PCI;
6601
6602    /* Downlink Config Common */
6603    DU_ALLOC(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
6604    if(!spCellConfigCommon->downlinkConfigCommon)
6605    {
6606       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
6607       return RFAILED;
6608    }
6609    if((BuildDlConfigCommon(spCellConfigCommon->downlinkConfigCommon)) != ROK)
6610    {
6611       DU_LOG("\nERROR  -->  DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
6612       return RFAILED;
6613    }
6614
6615    /* Uplinlink Config Common */
6616    DU_ALLOC(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
6617    if(!spCellConfigCommon->uplinkConfigCommon)
6618    {
6619       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
6620       return RFAILED;
6621    }
6622    if((BuildUlConfigCommon(spCellConfigCommon->uplinkConfigCommon)) != ROK)
6623    {
6624       DU_LOG("\nERROR  -->  DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
6625       return RFAILED;
6626    }
6627
6628    /* Timing Advance offset */
6629    DU_ALLOC(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
6630    if(!spCellConfigCommon->n_TimingAdvanceOffset)
6631    {
6632       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
6633       return RFAILED;
6634    }
6635    *(spCellConfigCommon->n_TimingAdvanceOffset) = ServingCellConfigCommon__n_TimingAdvanceOffset_n0;
6636
6637    /* SSB Position In Burst */
6638    DU_ALLOC(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
6639    if(!spCellConfigCommon->ssb_PositionsInBurst)
6640    {
6641       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
6642       return RFAILED;
6643    }
6644    if((BuildSsbPosInBurst(spCellConfigCommon->ssb_PositionsInBurst)) != ROK)
6645    {
6646       DU_LOG("\nERROR  -->  DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
6647       return RFAILED;
6648    }
6649
6650    /* SSB Periodicity in Serving cell */
6651    DU_ALLOC(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
6652    if(!spCellConfigCommon->ssb_periodicityServingCell)
6653    {
6654       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
6655          BuildSpCellConfigCommon()");
6656       return RFAILED;
6657    }
6658    *(spCellConfigCommon->ssb_periodicityServingCell) = \
6659       convertSsbPeriodicityValueToEnum(duCfgParam.sib1Params.srvCellCfgCommSib.ssbPrdServingCell);
6660
6661    /* DMRS Type A position */
6662    spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.dmrsTypeAPos);
6663
6664    /* SSB subcarrier spacing */
6665    DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
6666    if(!spCellConfigCommon->ssbSubcarrierSpacing)
6667    {
6668       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
6669       return RFAILED;
6670    }
6671    *(spCellConfigCommon->ssbSubcarrierSpacing) = duCfgParam.sib1Params.srvCellCfgCommSib.scs;
6672
6673    /* TDD UL-DL configuration common */
6674    DU_ALLOC(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
6675    if(!spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)
6676    {
6677       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
6678       return RFAILED;
6679    }
6680    if((BuildTddUlDlCfgComm(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)) != ROK)
6681    {
6682       DU_LOG("\nERROR  -->  DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
6683       return RFAILED;
6684    }
6685
6686    /* SS PBCH Block Power */
6687    spCellConfigCommon->ss_PBCH_BlockPower = duCfgParam.sib1Params.srvCellCfgCommSib.ssPbchBlockPwr;
6688
6689    return ROK;
6690 }
6691
6692 /*******************************************************************
6693  *
6694  * @brief Fills dedicated RACH configuration in Reconfiguration with sync
6695  *
6696  * @details
6697  *
6698  *    Function : BuildRecfgWithSync
6699  *
6700  *    Functionality:
6701  *       Fills dedicated RACH configuration in Reconfiguration with sync
6702  *
6703  * @params[in] DU UE CB
6704  *             Pointer to Rach config dedicated struct
6705  *
6706  * @return ROK     - success
6707  *         RFAILED - failure
6708  *
6709  * ****************************************************************/
6710 uint8_t BuildRachConfigDedicated(DuUeCb *ueCb, struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
6711 {
6712    uint8_t elementCnt = 0, listIdx = 0;
6713    CFRA_t *cfra = NULLP;
6714    struct CFRA__resources__ssb *ssbResource = NULLP;
6715    RachCfgCommon duRachCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.rachCfg;
6716
6717    rachCfgDed->present = ReconfigurationWithSync__rach_ConfigDedicated_PR_uplink;
6718
6719    /* Uplink */
6720    DU_ALLOC(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
6721    if(!rachCfgDed->choice.uplink)
6722    {
6723       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
6724       return RFAILED;
6725    }
6726
6727    /* CFRA : Contention free Random Access */
6728    DU_ALLOC(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
6729    if(!rachCfgDed->choice.uplink->cfra)
6730    {
6731       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
6732       return RFAILED;
6733    }
6734    cfra = rachCfgDed->choice.uplink->cfra;
6735
6736    /* CFRA occassions */
6737    DU_ALLOC(cfra->occasions, sizeof(struct CFRA__occasions));
6738    if(!cfra->occasions)
6739    {
6740       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
6741       return RFAILED;
6742    }
6743
6744    /* CFRA occassions : RACH generic configuration */
6745    cfra->occasions->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
6746    cfra->occasions->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
6747    cfra->occasions->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
6748    cfra->occasions->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
6749    cfra->occasions->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
6750    cfra->occasions->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
6751    cfra->occasions->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
6752    cfra->occasions->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
6753
6754    /* CFRA occassions : SSB per RACH occasion */
6755    DU_ALLOC(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
6756    if(!cfra->occasions->ssb_perRACH_Occasion)
6757    {
6758       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
6759       return RFAILED;
6760    }
6761    *(cfra->occasions->ssb_perRACH_Occasion) = convertCFRASsbPerRachOccasionValueToEnum(duCfgParam.macCellCfg.prachCfg.ssbPerRach);
6762
6763    /* CFRA resource */
6764    cfra->resources.present = CFRA__resources_PR_ssb;
6765
6766    /* CFRA resource : SSB */
6767    DU_ALLOC(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
6768    if(!cfra->resources.choice.ssb)
6769    {
6770       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
6771       return RFAILED;
6772    }
6773    ssbResource = cfra->resources.choice.ssb;
6774
6775    /* CFRA SSB resource list */
6776    elementCnt = ueCb->cfraResource.numSsb;
6777    ssbResource->ssb_ResourceList.list.count = elementCnt;
6778    ssbResource->ssb_ResourceList.list.size = elementCnt * sizeof(CFRA_SSB_Resource_t *);
6779
6780    DU_ALLOC(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
6781    if(!ssbResource->ssb_ResourceList.list.array)
6782    {
6783       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
6784       return RFAILED;
6785    }
6786
6787    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6788    {
6789       DU_ALLOC(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
6790       if(!ssbResource->ssb_ResourceList.list.array[listIdx])
6791       {
6792          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
6793          return RFAILED;
6794       }
6795       ssbResource->ssb_ResourceList.list.array[listIdx]->ssb = ueCb->cfraResource.ssbResource[listIdx].ssbIdx;
6796       ssbResource->ssb_ResourceList.list.array[listIdx]->ra_PreambleIndex = ueCb->cfraResource.ssbResource[listIdx].raPreambleIdx;
6797    }
6798
6799    return ROK;
6800 }
6801
6802 /*******************************************************************
6803  *
6804  * @brief Fills reconfiguration with sync in SP cell config
6805  *
6806  * @details
6807  *
6808  *    Function : BuildRecfgWithSync
6809  *
6810  *    Functionality: Fills reconfiguration with sync in SP cell config
6811  *
6812  * @params[in] DU UE CB
6813  *             Pointer to ReconfigurationWithSync_t
6814  *
6815  * @return ROK     - success
6816  *         RFAILED - failure
6817  *
6818  * ****************************************************************/
6819 uint8_t BuildRecfgWithSync(DuUeCb *ueCb, ReconfigurationWithSync_t *recfgWithSync)
6820 {
6821    /* SP Cell Config Common */
6822    DU_ALLOC(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
6823    if(!recfgWithSync->spCellConfigCommon)
6824    {
6825       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
6826       return RFAILED;
6827    }
6828
6829    if((BuildSpCellConfigCommon(recfgWithSync->spCellConfigCommon)) != ROK)
6830    {
6831       DU_LOG("\nERROR  -->  DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
6832       return RFAILED;
6833    }
6834
6835    /* New UE Identity */
6836    recfgWithSync->newUE_Identity = ueCb->crnti;
6837
6838    /* T304 timer */
6839    recfgWithSync->t304 = ReconfigurationWithSync__t304_ms1000;
6840
6841    /* RACH configuration dedicated */
6842    DU_ALLOC(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
6843    if(!recfgWithSync->rach_ConfigDedicated)
6844    {
6845       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
6846       return RFAILED;
6847    }
6848
6849    if((BuildRachConfigDedicated(ueCb, recfgWithSync->rach_ConfigDedicated)) != ROK)
6850    {
6851       DU_LOG("\nERROR  -->  DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
6852       return RFAILED;
6853    }
6854
6855    return ROK;
6856 }
6857
6858 /*******************************************************************
6859  *
6860  * @brief Builds Spcell config
6861  *
6862  * @details
6863  *
6864  *    Function : BuildSpCellCfg
6865  *
6866  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6867  *
6868  * @params[in] SpCellConfig_t spCellCfg
6869  *
6870  * @return ROK     - success
6871  *         RFAILED - failure
6872  *
6873  * ****************************************************************/
6874 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6875 {
6876    spCellCfg->servCellIndex = NULLP;
6877    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6878    if(!spCellCfg->servCellIndex)
6879    {
6880       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6881       return RFAILED;
6882    }
6883
6884    if(ueCb == NULLP)
6885       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6886    else
6887       *(spCellCfg->servCellIndex) = ueCb->macUeCfg.spCellCfg.servCellIdx;
6888
6889    spCellCfg->reconfigurationWithSync = NULLP;
6890    if(ueCb && (ueCb->ueState == UE_HANDIN_IN_PROGRESS))
6891    {
6892       DU_ALLOC(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
6893       if(!spCellCfg->reconfigurationWithSync)
6894       {
6895          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6896          return RFAILED;
6897       }
6898
6899       if((BuildRecfgWithSync(ueCb, spCellCfg->reconfigurationWithSync)) != ROK)
6900       {
6901          DU_LOG("\nERROR  -->  F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
6902          return RFAILED;
6903       }
6904    }
6905
6906    spCellCfg->rlf_TimersAndConstants = NULLP;
6907    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6908
6909    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6910    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6911    {
6912       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6913       return RFAILED;
6914    }
6915    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6916
6917    spCellCfg->spCellConfigDedicated = NULLP;
6918    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6919    if(!spCellCfg->spCellConfigDedicated)
6920    {
6921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6922       return RFAILED;
6923    }
6924    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6925    {
6926       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6927       return RFAILED;
6928    }
6929
6930    return ROK;
6931 }
6932
6933 /*******************************************************************
6934  *
6935  * @brief Builds Phy cell group config
6936  *
6937  * @details
6938  *
6939  *    Function : BuildPhyCellGrpCfg
6940  *
6941  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6942  *
6943  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
6944  *
6945  * @return ROK     - success
6946  *         RFAILED - failure
6947  *
6948  * ****************************************************************/
6949 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
6950 {
6951    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
6952    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
6953
6954    phyCellGrpCfg->p_NR_FR1 = NULLP;
6955    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6956    if(!phyCellGrpCfg->p_NR_FR1)
6957    {
6958       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
6959       return RFAILED;
6960    }
6961
6962    if(ueCb == NULLP)
6963    {
6964       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
6965       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
6966    }
6967    else
6968    {
6969       *(phyCellGrpCfg->p_NR_FR1) = ueCb->macUeCfg.phyCellGrpCfg.pNrFr1;
6970       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->macUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
6971    }
6972
6973    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
6974    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
6975    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
6976    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
6977    phyCellGrpCfg->cs_RNTI = NULLP;
6978    phyCellGrpCfg->ext1 = NULLP;
6979    phyCellGrpCfg->ext2 = NULLP;
6980
6981    return ROK;
6982 }
6983
6984 /*******************************************************************
6985  *
6986  * @brief Builds Mac cell group config
6987  *
6988  * @details
6989  *
6990  *    Function : BuildMacCellGrpCfg
6991  *
6992  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
6993  *
6994  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
6995  *
6996  * @return ROK     - success
6997  *         RFAILED - failure
6998  *
6999  * ****************************************************************/
7000 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
7001 {
7002    macCellGrpCfg->drx_Config = NULLP;
7003    macCellGrpCfg->schedulingRequestConfig = NULLP;
7004    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7005    if(!macCellGrpCfg->schedulingRequestConfig)
7006    {
7007       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7008       return RFAILED;
7009    }
7010
7011    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
7012    {
7013       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
7014       return RFAILED;
7015    }
7016
7017    macCellGrpCfg->bsr_Config = NULLP;
7018    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7019    if(!macCellGrpCfg->bsr_Config)
7020    {
7021       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7022       return RFAILED;
7023    }
7024
7025    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
7026    {
7027       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
7028       return RFAILED;
7029    }
7030
7031    macCellGrpCfg->tag_Config = NULLP;
7032    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
7033    if(!macCellGrpCfg->tag_Config)
7034    {
7035       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7036       return RFAILED;
7037    }
7038
7039    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
7040    {
7041       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
7042       return RFAILED;
7043    }
7044
7045    macCellGrpCfg->phr_Config = NULLP;
7046    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
7047    if(!macCellGrpCfg->phr_Config)
7048    {
7049       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7050       return RFAILED;
7051    }
7052
7053    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
7054    {
7055       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
7056       return RFAILED;
7057    }
7058
7059    macCellGrpCfg->skipUplinkTxDynamic = false;
7060    macCellGrpCfg->ext1 = NULLP;
7061
7062    return ROK;
7063 }
7064 /*******************************************************************
7065  *
7066  * @brief Frees memeory allocated for SearchSpcToAddModList
7067  *
7068  * @details
7069  *
7070  *    Function : FreeSearchSpcToAddModList
7071  *
7072  *    Functionality: Deallocating memory of SearchSpcToAddModList
7073  *
7074  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7075  *
7076  * @return void
7077  *
7078  4221 * ****************************************************************/
7079 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7080 {
7081    uint8_t idx1=0;
7082    uint8_t idx2=0;
7083    struct  SearchSpace *searchSpc=NULLP;
7084
7085    if(searchSpcList->list.array)
7086    {
7087       if(searchSpcList->list.array[idx2])
7088       {
7089          searchSpc = searchSpcList->list.array[idx2];
7090          if(searchSpc->controlResourceSetId)
7091          {
7092             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7093             {
7094                if(searchSpc->monitoringSymbolsWithinSlot)
7095                {
7096                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7097                   {
7098                      if(searchSpc->nrofCandidates)
7099                      {
7100                         if(searchSpc->searchSpaceType)
7101                         {
7102                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
7103                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
7104                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
7105                                     SearchSpace__searchSpaceType));
7106                         }
7107                         DU_FREE(searchSpc->nrofCandidates,
7108                               sizeof(struct SearchSpace__nrofCandidates));
7109                      }
7110                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
7111                            searchSpc->monitoringSymbolsWithinSlot->size);
7112                   }
7113                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
7114                         sizeof(BIT_STRING_t));
7115                }
7116                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
7117                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
7118             }
7119             DU_FREE(searchSpc->controlResourceSetId,
7120                   sizeof(ControlResourceSetId_t));
7121          }
7122       }
7123       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
7124       {
7125          DU_FREE(searchSpcList->list.array[idx1],
7126                sizeof(struct SearchSpace));
7127       }
7128       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
7129    }
7130 }
7131 /*******************************************************************
7132  *
7133  * @brief Frees memory allocated for PdschTimeDomAllocList
7134  *
7135  * @details
7136  *
7137  *    Function : FreePdschTimeDomAllocList
7138  *
7139  *    Functionality: Deallocating memory of PdschTimeDomAllocList
7140  *
7141  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7142  *
7143  * @return void
7144  *
7145  * ****************************************************************/
7146 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7147 {
7148    uint8_t idx1=0;
7149
7150    if(timeDomAllocList->choice.setup)
7151    {
7152       if(timeDomAllocList->choice.setup->list.array)
7153       {
7154          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
7155          {
7156             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
7157             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
7158                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
7159          }
7160          DU_FREE(timeDomAllocList->choice.setup->list.array, \
7161                timeDomAllocList->choice.setup->list.size);
7162       }
7163       DU_FREE(timeDomAllocList->choice.setup,\
7164             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
7165    }
7166 }
7167 /*******************************************************************
7168  *
7169  * @brief Frees memory allocated for PuschTimeDomAllocList
7170  *
7171  *@details
7172  *
7173  *    Function : FreePuschTimeDomAllocList
7174  *
7175  *    Functionality: Deallocating memory of PuschTimeDomAllocList
7176  *
7177  * @params[in] PUSCH_Config_t *puschCfg
7178  *
7179  * @return void
7180  *
7181  * ****************************************************************/
7182 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
7183 {
7184    uint8_t rsrcListIdx=0;
7185    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7186
7187    if(puschCfg->pusch_TimeDomainAllocationList)
7188    {
7189       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7190       if(timeDomAllocList_t->choice.setup)
7191       {
7192          if(timeDomAllocList_t->choice.setup->list.array)
7193          {
7194             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
7195             {
7196                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
7197                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
7198                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
7199             }
7200             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
7201                   timeDomAllocList_t->choice.setup->list.size);
7202          }
7203          DU_FREE(timeDomAllocList_t->choice.setup, \
7204                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
7205       }
7206       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
7207       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
7208             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
7209    }
7210
7211 }
7212
7213 /*******************************************************************
7214  *
7215  * @brief Frees memory allocated for Dedicated PUCCH config
7216  *
7217  * @details
7218  *
7219  *    Function : FreeBWPUlDedPucchCfg
7220  *
7221  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
7222  *
7223  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
7224  *
7225  * @return void
7226  *
7227  * ****************************************************************/
7228 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
7229 {
7230    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
7231    PUCCH_Config_t *pucchCfg = NULLP;
7232    PUCCH_ResourceSet_t *rsrcSet = NULLP;
7233    PUCCH_Resource_t *rsrc = NULLP;
7234
7235    if(ulBwpPucchCfg)
7236    {
7237       if(ulBwpPucchCfg->choice.setup)
7238       {
7239          pucchCfg = ulBwpPucchCfg->choice.setup;
7240
7241          //Free resource set list
7242          if(pucchCfg->resourceSetToAddModList)
7243          {
7244             if(pucchCfg->resourceSetToAddModList->list.array)
7245             {
7246                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
7247                {
7248                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
7249                   if(rsrcSet->resourceList.list.array)
7250                   {
7251                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
7252                      {
7253                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
7254                      }
7255                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
7256                   }
7257                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
7258                }
7259                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
7260             }
7261             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
7262          }
7263
7264          //Free resource list
7265          if(pucchCfg->resourceToAddModList)
7266          {
7267             if(pucchCfg->resourceToAddModList->list.array)
7268             {
7269                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
7270                {
7271                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
7272                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
7273                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
7274                }
7275                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
7276             }
7277             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
7278          }
7279
7280          //PUCCH Format 1
7281          if(pucchCfg->format1)
7282          {
7283             if(pucchCfg->format1->choice.setup)
7284             {
7285                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
7286                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
7287             }
7288             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
7289          }
7290
7291          //DL DATA TO UL ACK
7292          if(pucchCfg->dl_DataToUL_ACK)
7293          {
7294             if(pucchCfg->dl_DataToUL_ACK->list.array)
7295             {
7296                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
7297                {
7298                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
7299                }
7300                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
7301             }
7302             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
7303          }
7304
7305          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
7306       }
7307       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
7308    }
7309 }
7310
7311 /*******************************************************************
7312  *
7313  * @brief Frees memory allocated for InitialUlBWP
7314  *
7315  * @details
7316  *
7317  *    Function : FreeInitialUlBWP
7318  *
7319  *    Functionality: Deallocating memory of InitialUlBWP
7320  *
7321  * @params[in] BWP_UplinkDedicated_t *ulBwp
7322  *
7323  * @return void
7324  *
7325  * ****************************************************************/
7326 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
7327 {
7328    uint8_t  rSetIdx, rsrcIdx;
7329    SRS_Config_t   *srsCfg = NULLP;
7330    PUSCH_Config_t *puschCfg = NULLP;
7331    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7332    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7333    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7334    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7335
7336    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
7337
7338    if(ulBwp->pusch_Config)
7339    {
7340       if(ulBwp->pusch_Config->choice.setup)
7341       {
7342          puschCfg=ulBwp->pusch_Config->choice.setup;
7343          if(puschCfg->dataScramblingIdentityPUSCH)
7344          {
7345             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7346             {
7347                FreePuschTimeDomAllocList(puschCfg);
7348                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7349                if(dmrsUlCfg->choice.setup)
7350                {
7351                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7352                   {
7353                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7354                      {
7355                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
7356                               sizeof(long));
7357                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
7358                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
7359                      }
7360                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
7361                            sizeof(long));
7362                   }
7363                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
7364                }
7365                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
7366                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
7367             }
7368             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
7369          }
7370          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
7371       }
7372       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
7373
7374       /* Free SRS-Config */
7375       if(ulBwp->srs_Config)
7376       {
7377          if(ulBwp->srs_Config->choice.setup)
7378          {
7379             srsCfg = ulBwp->srs_Config->choice.setup;
7380
7381             /* Free Resource Set to add/mod list */
7382             if(srsCfg->srs_ResourceSetToAddModList)
7383             {
7384                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7385                if(rsrcSetList->list.array)
7386                {
7387                   rSetIdx = 0;
7388
7389                   /* Free SRS resource Id list in this SRS resource set */
7390                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7391                   {
7392                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7393
7394                      if(rsrcIdList->list.array)
7395                      {
7396                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
7397                         {
7398                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
7399                         }
7400                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
7401                      }
7402                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
7403                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
7404                   }
7405
7406                   /* Free resource type info for this SRS resource set */
7407                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
7408                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
7409
7410                   /* Free memory for each resource set */
7411                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7412                   {
7413                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
7414                   }
7415                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
7416                }
7417                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
7418                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
7419             }
7420
7421             /* Free resource to add/modd list */
7422             if(srsCfg->srs_ResourceToAddModList)
7423             {
7424                resourceList = srsCfg->srs_ResourceToAddModList;
7425                if(resourceList->list.array)
7426                {
7427                   rsrcIdx = 0;
7428                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
7429                         sizeof(struct SRS_Resource__transmissionComb__n2));
7430                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
7431                         sizeof(struct SRS_Resource__resourceType__aperiodic));
7432
7433                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7434                   {
7435                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
7436                   }
7437                   DU_FREE(resourceList->list.array, resourceList->list.size);
7438                }
7439                DU_FREE(srsCfg->srs_ResourceToAddModList, \
7440                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
7441             }
7442
7443             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
7444          }
7445          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
7446       }
7447    }
7448 }
7449 /*******************************************************************
7450  *
7451  * @brief Frees memory allocated for initialUplinkBWP
7452  *
7453  * @details
7454  *
7455  *    Function : FreeinitialUplinkBWP
7456  *
7457  *    Functionality: Deallocating memory of initialUplinkBWP
7458  *
7459  * @params[in] UplinkConfig_t *ulCfg
7460  *
7461  * @return void
7462  *
7463  *
7464  * ****************************************************************/
7465 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
7466 {
7467    BWP_UplinkDedicated_t *ulBwp=NULLP;
7468    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7469
7470    if(ulCfg->initialUplinkBWP)
7471    {
7472       ulBwp=ulCfg->initialUplinkBWP;
7473       if(ulCfg->firstActiveUplinkBWP_Id)
7474       {
7475          if(ulCfg->pusch_ServingCellConfig)
7476          {
7477             puschCfg=ulCfg->pusch_ServingCellConfig;
7478             if(puschCfg->choice.setup)
7479             {
7480                if(puschCfg->choice.setup->ext1)
7481                {
7482                   DU_FREE(puschCfg->choice.setup->ext1->\
7483                         processingType2Enabled,sizeof(BOOLEAN_t));
7484                   DU_FREE(puschCfg->choice.setup->ext1->\
7485                         maxMIMO_Layers,sizeof(long));
7486                   DU_FREE(puschCfg->choice.setup->ext1, \
7487                         sizeof(struct PUSCH_ServingCellConfig__ext1));
7488                }
7489                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
7490             }
7491             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
7492          }
7493          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
7494       }
7495       FreeInitialUlBWP(ulBwp);
7496       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
7497    }
7498 }
7499 /*******************************************************************
7500  *
7501  * @brief Frees emmory allocated for BWPDlDedPdschCfg
7502  *
7503  * @details
7504  *
7505  *    Function : FreeBWPDlDedPdschCfg
7506  *
7507  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
7508  *
7509  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7510  *
7511  * @return void
7512  *
7513  *
7514  * ****************************************************************/
7515 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
7516 {
7517    struct PDSCH_Config *pdschCfg=NULLP;
7518    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7519    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7520    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7521
7522    if(dlBwp->pdsch_Config->choice.setup)
7523    {
7524       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7525       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7526       {
7527          if(pdschCfg->pdsch_TimeDomainAllocationList)
7528          {
7529             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7530             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7531             {
7532                prbBndlType=&pdschCfg->prb_BundlingType;
7533                DU_FREE(prbBndlType->choice.staticBundling,\
7534                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
7535                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
7536             }
7537             FreePdschTimeDomAllocList(timeDomAllocList);
7538             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
7539                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
7540          }
7541          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7542          if(dmrsDlCfg->choice.setup)
7543          {
7544             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
7545                   sizeof(long));
7546             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
7547          }
7548          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
7549                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
7550       }
7551       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
7552    }
7553 }
7554 /*******************************************************************
7555  *
7556  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
7557  *
7558  * @details
7559  *
7560  *    Function : FreeBWPDlDedPdcchCfg
7561  *
7562  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
7563  *
7564  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7565  *
7566  * @return void
7567  *
7568  *
7569  * ****************************************************************/
7570 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
7571 {
7572    uint8_t idx1=0;
7573    uint8_t idx2=0;
7574    struct PDCCH_Config *pdcchCfg=NULLP;
7575    struct ControlResourceSet *controlRSet=NULLP;
7576    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7577
7578    if(dlBwp->pdcch_Config->choice.setup)
7579    {
7580       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7581       if(pdcchCfg->controlResourceSetToAddModList)
7582       {
7583          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7584          if(controlRSetList->list.array)
7585          {
7586             controlRSet = controlRSetList->list.array[idx2];
7587             if(controlRSet)
7588             {
7589                if(controlRSet->frequencyDomainResources.buf)
7590                {
7591                   if(controlRSet->pdcch_DMRS_ScramblingID)
7592                   {
7593                      if(pdcchCfg->searchSpacesToAddModList)
7594                      {
7595                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7596                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
7597                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
7598                      }
7599                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
7600                   }
7601                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
7602                         controlRSet->frequencyDomainResources.size);
7603                }
7604             }
7605             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
7606             {
7607                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
7608             }
7609             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
7610          }
7611          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
7612                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
7613       }
7614       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
7615    }
7616 }
7617
7618 /*******************************************************************
7619  *
7620  * @brief Free SCS specific carrier list in DL frequency info
7621  *
7622  * @details
7623  *
7624  *    Function : FreeScsSpecificCarrierListDl
7625  *
7626  *    Functionality: Free SCS specific carrier list in DL frequency info
7627  *
7628  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
7629  *
7630  * @return void
7631  *
7632  * ****************************************************************/
7633 void FreeScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
7634 {
7635    uint8_t listIdx = 0;
7636
7637    if(!scsCarrierList->list.array)
7638    {
7639       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
7640       {
7641          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
7642       }
7643       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
7644    }
7645 }
7646
7647 /*******************************************************************
7648  *
7649  * @brief Free DL frequency info in DL config common
7650  *
7651  * @details
7652  *
7653  *    Function : FreeFreqInfoDl
7654  *
7655  *    Functionality: Free DL frequency info in DL config common
7656  *
7657  * @params[in] Pointer to DownlinkConfigCommon_t
7658  *
7659  * @return void
7660  *
7661  * ****************************************************************/
7662 void FreeFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
7663 {
7664    uint8_t freqBandIdx = 0;
7665
7666    /* SSB Absolute Frequency */
7667    DU_FREE(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
7668
7669    /* NR Multi Frequency Band List */
7670    if(frequencyInfoDL->frequencyBandList.list.array)
7671    {
7672       for(freqBandIdx = 0; freqBandIdx < frequencyInfoDL->frequencyBandList.list.count; freqBandIdx++)
7673       {
7674          DU_FREE(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
7675       }
7676       DU_FREE(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
7677    }
7678
7679    /* Subcarrier Spacing specifc carrier List */
7680    FreeScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList);
7681 }
7682
7683 /*******************************************************************
7684  *
7685  * @brief Free DL config common in Serving cell config common
7686  *
7687  * @details
7688  *
7689  *    Function : FreeDlConfigCommon
7690  *
7691  *    Functionality: Free DL config common in Serving cell config common
7692  *
7693  * @params[in] Pointer to DownlinkConfigCommon_t
7694  *
7695  * @return void
7696  *
7697  * ****************************************************************/
7698 void FreeDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
7699 {
7700    /* DL Frequency Info */
7701    if(dlCfgCommon->frequencyInfoDL)
7702    {
7703       FreeFreqInfoDl(dlCfgCommon->frequencyInfoDL);
7704       DU_FREE(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
7705    }
7706
7707    /* DL BWP config common */
7708    if(dlCfgCommon->initialDownlinkBWP)
7709    {
7710       FreeBwpDlCommon(dlCfgCommon->initialDownlinkBWP);
7711       DU_FREE(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
7712    }
7713 }
7714
7715 /*******************************************************************
7716  *
7717  * @brief Free SCS specific carrier list in UL frequency Info
7718  *
7719  * @details
7720  *
7721  *    Function : FreeScsSpecificCarrierListUl
7722  *
7723  *    Functionality: Free SCS specific carrier list in UL frequency Info
7724  *
7725  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
7726  *
7727  * @return void
7728  *
7729  * ****************************************************************/
7730 void FreeScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
7731 {
7732    uint8_t listIdx = 0;
7733
7734    if(scsCarrierList->list.array)
7735    {
7736       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
7737       {
7738          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
7739       }
7740       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
7741    }
7742 }
7743
7744 /*******************************************************************
7745  *
7746  * @brief Free frequency info in UL config common
7747  *
7748  * @details
7749  *
7750  *    Function : FreeFreqInfoUl
7751  *
7752  *    Functionality: Free frequency info in UL config common
7753  *
7754  * @params[in] Pointer to FrequencyInfoUL_t
7755  *
7756  * @return void
7757  *
7758  * ****************************************************************/
7759 void FreeFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
7760 {
7761    uint8_t listIdx= 0;
7762
7763    /* NR Multi Frequency Band List */
7764    if(!frequencyInfoUL->frequencyBandList)
7765    {
7766       if(frequencyInfoUL->frequencyBandList->list.array)
7767       {
7768          for(listIdx = 0; listIdx < frequencyInfoUL->frequencyBandList->list.count; listIdx++)
7769          {
7770             DU_FREE(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
7771          }
7772          DU_FREE(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
7773       }
7774       DU_FREE(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
7775    }
7776
7777    /* Absolute frequency point A */
7778    DU_FREE(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
7779
7780    /* Subcarrier Spacing specifc carrier */
7781    FreeScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList);
7782
7783    /* P-MAX */
7784    DU_FREE(frequencyInfoUL->p_Max, sizeof(P_Max_t));
7785 }
7786
7787 /*******************************************************************
7788  *
7789  * @brief Free UL config common in Serving cell config common
7790  *
7791  * @details
7792  *
7793  *    Function : FreeUlConfigCommon
7794  *
7795  *    Functionality: Free UL config common in Serving cell config common
7796  *
7797  * @params[in] Pointer to UplinkConfigCommon_t
7798  *
7799  * @return void
7800  *
7801  * ****************************************************************/
7802 void FreeUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
7803 {
7804    /* UL Frequency Info */
7805    if(ulCfgCommon->frequencyInfoUL)
7806    {
7807       FreeFreqInfoUl(ulCfgCommon->frequencyInfoUL);
7808       DU_FREE(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
7809    }
7810
7811    /* UL BWP common */
7812    if(ulCfgCommon->initialUplinkBWP)
7813    {
7814       FreeBwpUlCommon(ulCfgCommon->initialUplinkBWP);
7815       DU_FREE(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
7816    }
7817 }
7818
7819 /*******************************************************************
7820  *
7821  * @brief Free SP cell config common in Reconfig with Sync
7822  *
7823  * @details
7824  *
7825  *    Function : FreeSpCellConfigCommon
7826  *
7827  *    Functionality: Free SP cell config common in Reconfig with Sync
7828  *
7829  * @params[in] Pointer to ServingCellConfigCommon_t
7830  *
7831  * @return void
7832  *
7833  * ****************************************************************/
7834 void FreeSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
7835 {
7836    /* Free Physical cell identity */
7837    DU_FREE(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
7838
7839    /* Free Downlink Config common */
7840    if(spCellConfigCommon->downlinkConfigCommon)
7841    {
7842       FreeDlConfigCommon(spCellConfigCommon->downlinkConfigCommon);
7843       DU_FREE(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
7844    }
7845
7846    /* Free Uplink Config common */
7847    if(spCellConfigCommon->uplinkConfigCommon)
7848    {
7849       FreeUlConfigCommon(spCellConfigCommon->uplinkConfigCommon);
7850       DU_FREE(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
7851    }
7852
7853    /* Free Timing Advance offset */
7854    DU_FREE(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
7855
7856    /* Free SSB Position in Burst */
7857    if(spCellConfigCommon->ssb_PositionsInBurst)
7858    {
7859       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.buf, \
7860          spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.size);
7861       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
7862    }
7863
7864    /* Free SSB Periodicity in Serving cell */
7865    DU_FREE(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
7866
7867    /* Free SSB subcarrier spacing */
7868    DU_FREE(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7869
7870    /* TDD UL-DL configuration common */
7871    DU_FREE(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
7872 }
7873
7874 /*******************************************************************
7875  *
7876  * @brief Free dedicated RACH configuration in Reconfiguration with sync
7877  *
7878  * @details
7879  *
7880  *    Function : FreeRecfgWithSync
7881  *
7882  *    Functionality:
7883  *       Free dedicated RACH configuration in Reconfiguration with sync
7884  *
7885  * @params[in] Pinter to Rach config dedicated struct
7886  *
7887  * @return void
7888  *
7889  * ****************************************************************/
7890 void FreeRachConfigDedicated(struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
7891 {
7892    uint8_t listIdx = 0;
7893    CFRA_t *cfra = NULLP;
7894    struct CFRA__resources__ssb *ssbResource = NULLP;
7895
7896    /* Uplink */
7897    if(rachCfgDed->choice.uplink)
7898    {
7899       /* CFRA : Contention free Random Access */
7900       if(rachCfgDed->choice.uplink->cfra)
7901       {
7902          cfra = rachCfgDed->choice.uplink->cfra;
7903
7904          /* CFRA occassions */
7905          if(cfra->occasions)
7906          {
7907             /* CFRA occassions : SSB per RACH occasion */
7908             DU_FREE(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
7909             DU_FREE(cfra->occasions, sizeof(struct CFRA__occasions));
7910          }
7911
7912          /* CFRA resource */
7913          cfra->resources.present = CFRA__resources_PR_ssb;
7914
7915          /* CFRA resource : SSB */
7916          if(cfra->resources.choice.ssb)
7917          {
7918             ssbResource = cfra->resources.choice.ssb;
7919
7920             /* CFRA SSB resource list */
7921             if(ssbResource->ssb_ResourceList.list.array)
7922             {
7923                for(listIdx = 0; listIdx < ssbResource->ssb_ResourceList.list.count; listIdx++)
7924                {
7925                   DU_FREE(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
7926                }
7927                DU_FREE(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
7928             }
7929             DU_FREE(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
7930          }
7931          DU_FREE(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
7932       }
7933       DU_FREE(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
7934    }
7935 }
7936
7937 /*******************************************************************
7938  *
7939  * @brief Frees reconfiguration with sync in SP cell config
7940  *
7941  * @details
7942  *
7943  *    Function : FreeRecfgWithSync
7944  *
7945  *    Functionality: Fress reconfiguration with sync in SP cell config
7946  *
7947  * @params[in] Pointer to ReconfigurationWithSync_t
7948  *
7949  * @return void
7950  *
7951  * ****************************************************************/
7952 void FreeRecfgWithSync(ReconfigurationWithSync_t *recfgWithSync)
7953 {
7954    /* Free SP Cell config common */
7955    if(recfgWithSync->spCellConfigCommon)
7956    {
7957       FreeSpCellConfigCommon(recfgWithSync->spCellConfigCommon);
7958       DU_FREE(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
7959    }
7960
7961    /* Free Dedicated RACH configuration */
7962    if(recfgWithSync->rach_ConfigDedicated)
7963    {
7964       FreeRachConfigDedicated(recfgWithSync->rach_ConfigDedicated);
7965       DU_FREE(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
7966    }
7967 }
7968
7969 /*******************************************************************
7970  *
7971  * @brief Frees emmory allocated for DUToCURRCContainer
7972  *
7973  * @details
7974  *
7975  *    Function : FreeMemDuToCuRrcCont
7976  *
7977  *    Functionality: Deallocating memory of DuToCuRrcContainer
7978  *
7979  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
7980  *
7981  * @return ROK     - success
7982  *         RFAILED - failure
7983  *
7984  * ****************************************************************/
7985 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
7986 {
7987    uint8_t idx=0;
7988    SpCellConfig_t *spCellCfg=NULLP;
7989    ServingCellConfig_t *srvCellCfg=NULLP;
7990    BWP_DownlinkDedicated_t *dlBwp=NULLP;
7991    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
7992    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
7993    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
7994    struct RLC_Config *rlcConfig=NULLP;
7995    struct LogicalChannelConfig *macLcConfig=NULLP;
7996    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
7997    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
7998    struct TAG_Config *tagConfig=NULLP;
7999    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
8000    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
8001    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
8002
8003    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8004    if(rlcBearerList)
8005    {
8006       if(rlcBearerList->list.array)
8007       {
8008          for(idx=0; idx<rlcBearerList->list.count; idx++)
8009          {
8010             if(rlcBearerList->list.array[idx])
8011             {
8012                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
8013                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
8014                if(rlcConfig)
8015                {
8016                   switch(rlcConfig->present)
8017                   {
8018                      case RLC_Config_PR_am:
8019                         {
8020                            if(rlcConfig->choice.am)
8021                            {
8022                               DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8023                               DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8024                               DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
8025                            }
8026                            break;
8027                         }
8028                      case RLC_Config_PR_um_Bi_Directional:
8029                         {
8030                            if(rlcConfig->choice.um_Bi_Directional)
8031                            {
8032                               DU_FREE(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8033                               DU_FREE(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8034                               DU_FREE(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
8035                            }
8036                            break;
8037                         }
8038                      case RLC_Config_PR_um_Uni_Directional_UL:
8039                         {
8040                            if(rlcConfig->choice.um_Uni_Directional_UL)
8041                            {
8042                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8043                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
8044                            }
8045                            break;
8046                         }
8047                      case RLC_Config_PR_um_Uni_Directional_DL:
8048                         {
8049                            if(rlcConfig->choice.um_Uni_Directional_DL )
8050                            {
8051                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8052                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
8053                            }
8054                            break;
8055                         }
8056                   }
8057                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
8058                }
8059                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
8060                if(macLcConfig)
8061                {
8062                   if(macLcConfig->ul_SpecificParameters)
8063                   {
8064                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
8065                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
8066                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
8067                   }
8068                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
8069                }
8070                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
8071             }
8072          }
8073          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
8074       }
8075       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8076    }
8077
8078    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8079    if(macCellGrpCfg)
8080    {
8081       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8082       if(schedulingRequestConfig)
8083       {
8084          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8085          if(schReqList)
8086          {
8087             if(schReqList->list.array)
8088             {
8089                for(idx=0;idx<schReqList->list.count; idx++)
8090                {
8091                   if(schReqList->list.array[idx])
8092                   {
8093                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
8094                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
8095                   }
8096                }
8097                DU_FREE(schReqList->list.array, schReqList->list.size);
8098             }
8099             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
8100                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
8101             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
8102       }
8103       if(macCellGrpCfg->bsr_Config)
8104       {
8105          DU_FREE(macCellGrpCfg->bsr_Config->logicalChannelSR_DelayTimer, sizeof(long));
8106          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
8107       }
8108       tagConfig = macCellGrpCfg->tag_Config;
8109       if(tagConfig)
8110       {
8111          tagList = tagConfig->tag_ToAddModList;
8112          if(tagList)
8113          {
8114             if(tagList->list.array)
8115             {
8116                for(idx=0; idx<tagList->list.count; idx++)
8117                {
8118                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
8119                }
8120                DU_FREE(tagList->list.array, tagList->list.size);
8121             }
8122             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
8123          }
8124          DU_FREE(tagConfig, sizeof(struct TAG_Config));
8125       }
8126
8127       phrConfig = macCellGrpCfg->phr_Config;
8128       if(phrConfig)
8129       {
8130          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
8131          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
8132       }
8133
8134       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
8135    }
8136
8137    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8138    if(phyCellGrpCfg)
8139    {
8140       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
8141       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
8142    }
8143
8144    spCellCfg = cellGrpCfg->spCellConfig;
8145    if(spCellCfg)
8146    {
8147       /* Free serving cell index */
8148       DU_FREE(spCellCfg->servCellIndex, sizeof(long));
8149
8150       /* Free Reconfiguration with sync */
8151       if(spCellCfg->reconfigurationWithSync)
8152       {
8153          FreeRecfgWithSync(spCellCfg->reconfigurationWithSync);
8154          DU_FREE(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
8155       }
8156
8157       /* Free rlmInSyncOutOfSyncThreshold */
8158       DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
8159
8160       /* Free SP Cell config dedicated */
8161       if(spCellCfg->spCellConfigDedicated)
8162       {
8163          srvCellCfg = spCellCfg->spCellConfigDedicated;
8164
8165          /* Free TDD UL-DL config dedicated */
8166          DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
8167
8168          /* Free Initial Downlink BWP */
8169          if(srvCellCfg->initialDownlinkBWP)
8170          {
8171             dlBwp = srvCellCfg->initialDownlinkBWP;
8172
8173             /* Free DL BWP PDCCH Config */
8174             if(dlBwp->pdcch_Config)
8175             {
8176                FreeBWPDlDedPdcchCfg(dlBwp);
8177                DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
8178             }
8179
8180             /* Free DL BWP PDSCH config */
8181             if(dlBwp->pdsch_Config)
8182             {
8183                FreeBWPDlDedPdschCfg(dlBwp);
8184                DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
8185             }
8186             DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
8187          }
8188
8189          /* Free First Active Downlink BWP */
8190          DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
8191
8192          /* Free Default downlink BWP */
8193          DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
8194
8195          /* Free Uplink config */
8196          if(srvCellCfg->uplinkConfig)
8197          {
8198             FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
8199             DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
8200          }
8201
8202          /* Free PDSCH serving cell config */
8203          if(srvCellCfg->pdsch_ServingCellConfig)
8204          {
8205             pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
8206             if(pdschCfg->choice.setup)
8207             {
8208                DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
8209                DU_FREE(pdschCfg->choice.setup, sizeof(struct PDSCH_ServingCellConfig));
8210             }
8211             DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
8212          }
8213
8214          DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
8215       }
8216       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
8217    }
8218    return ROK;
8219 }
8220
8221 /*******************************************************************
8222  *
8223  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
8224  *
8225  * @details
8226  *
8227  *    Function : BuildCellGroupConfigRrc
8228  *
8229  *    Functionality: Builds and copied Cell group config buffer into
8230  *       DuToCuRrcContainer
8231  *
8232  * @params[in] idx, index in F1AP msg
8233  *             DuToCuRRCContainer, DuToCuRRCContainer
8234  *
8235  * @return ROK     - success
8236  *         RFAILED - failure
8237  *
8238  * ****************************************************************/
8239 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
8240 {
8241    uint8_t  ret = ROK;
8242    CellGroupConfigRrc_t  cellGrpCfg;
8243    asn_enc_rval_t        encRetVal;
8244    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
8245    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8246
8247    while(true)
8248    {
8249       cellGrpCfg.cellGroupId = CELL_GRP_ID;
8250
8251       cellGrpCfg.rlc_BearerToAddModList = NULLP;
8252       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8253       if(!cellGrpCfg.rlc_BearerToAddModList)
8254       {
8255          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8256          ret = RFAILED;
8257          break;
8258       }
8259       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
8260       {
8261          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
8262          ret = RFAILED;
8263          break;
8264       }
8265
8266       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
8267       cellGrpCfg.mac_CellGroupConfig = NULLP;
8268       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
8269       if(!cellGrpCfg.mac_CellGroupConfig)
8270       {
8271          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8272          ret = RFAILED;
8273          break;
8274       }
8275       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
8276       {
8277          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
8278          ret = RFAILED;
8279          break;
8280       }
8281
8282       cellGrpCfg.physicalCellGroupConfig = NULLP;
8283       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
8284       if(!cellGrpCfg.physicalCellGroupConfig)
8285       {
8286          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8287          ret = RFAILED;
8288          break;
8289       }
8290       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
8291       {
8292          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
8293          ret = RFAILED;
8294          break;
8295       }
8296
8297       cellGrpCfg.spCellConfig = NULLP;
8298       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
8299       if(!cellGrpCfg.spCellConfig)
8300       {
8301          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8302          ret = RFAILED;
8303          break;
8304       }
8305       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
8306       {
8307          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
8308          ret = RFAILED;
8309          break;
8310       }
8311
8312       cellGrpCfg.sCellToAddModList = NULLP;
8313       cellGrpCfg.sCellToReleaseList = NULLP;
8314       cellGrpCfg.ext1 = NULLP;
8315
8316       /* encode cellGrpCfg into duToCuRrcContainer */
8317       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
8318       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8319       encBufSize = 0;
8320       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
8321       /* Encode results */
8322       if(encRetVal.encoded == ENCODE_FAIL)
8323       {
8324          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
8325                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8326          ret = RFAILED;
8327          break;
8328       }
8329       else
8330       {
8331          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
8332          for(int i=0; i< encBufSize; i++)
8333          {
8334             printf("%x",encBuf[i]);
8335          }
8336       }
8337
8338       duToCuRrcContainer->size = encBufSize;
8339       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
8340       if(!duToCuRrcContainer->buf)
8341       {
8342          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
8343          ret = RFAILED;
8344          break;
8345       }
8346       if(ret == ROK)
8347       {
8348          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
8349       }
8350       break;
8351    }
8352    FreeMemDuToCuRrcCont(&cellGrpCfg);
8353    return ret;
8354 }
8355
8356 /*******************************************************************
8357  *
8358  * @brief Free memory allocated in InitialULRRCMessage
8359  *
8360  * @details
8361  *
8362  *    Function : freeInitUlRrcMsgTransfer
8363  *
8364  *    Functionality: Free memory allocated in InitialULRRCMessage
8365  *
8366  * @params[in]F1AP_PDU_t  *f1apMsg)
8367  *
8368  * @return ROK     - success
8369  *         RFAILED - failure
8370  *
8371  * ****************************************************************/
8372
8373 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
8374 {
8375    uint8_t ieIdx, arrIdx;
8376    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
8377
8378    if(f1apMsg)
8379    {
8380       if(f1apMsg->choice.initiatingMessage)
8381       {
8382          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
8383             choice.InitialULRRCMessageTransfer;
8384          if(initULRRCMsg->protocolIEs.list.array)
8385          {
8386             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
8387             {
8388                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
8389                {
8390                   case ProtocolIE_ID_id_NRCGI:
8391                   {
8392                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
8393                      {
8394                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
8395                         {
8396                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
8397                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
8398                         }
8399                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
8400                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
8401                      }
8402                      break;
8403                   }
8404                   case ProtocolIE_ID_id_RRCContainer:
8405                   {
8406                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8407                      {
8408                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
8409                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8410                      }
8411                      break;
8412                   }
8413                   case ProtocolIE_ID_id_DUtoCURRCContainer:
8414                   {
8415                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
8416                      {
8417                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
8418                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
8419                      }
8420                      break;
8421                   }
8422                   default:
8423                      break;
8424                }
8425              }
8426              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8427              {
8428                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
8429                 {
8430                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
8431                       sizeof(InitialULRRCMessageTransferIEs_t));
8432                 }
8433              }
8434              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
8435           }
8436          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8437       }
8438       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
8439    }
8440    else
8441    {
8442       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
8443       return RFAILED;
8444    }
8445    return ROK;
8446 }
8447
8448 /*******************************************************************
8449  *
8450  * @brief Builds and sends the InitialULRRCMessage
8451  *
8452  * @details
8453  *
8454  *    Function : BuildAndSendInitialRrcMsgTransfer
8455  *
8456  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
8457  *                   it to the CU through SCTP.
8458  *
8459  * @params[in]
8460  *
8461  * @return ROK     - success
8462  *         RFAILED - failure
8463  *
8464  * ****************************************************************/
8465 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
8466       uint16_t rrcContSize, uint8_t *rrcContainer)
8467 {
8468    uint8_t   ret;
8469    uint8_t   elementCnt;
8470    uint8_t   ieIdx, cellIdx, ueIdx;
8471    DuUeCb    *duUeCb = NULLP;
8472    asn_enc_rval_t  encRetVal;
8473    F1AP_PDU_t  *f1apMsg = NULLP;
8474    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
8475    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8476
8477    while(true)
8478    {
8479       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
8480       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8481       if(f1apMsg == NULLP)
8482       {
8483          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8484          break;
8485       }
8486       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8487       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8488       if(f1apMsg->choice.initiatingMessage == NULLP)
8489       {
8490          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
8491          break;
8492       }
8493       f1apMsg->choice.initiatingMessage->procedureCode =\
8494                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
8495       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
8496       f1apMsg->choice.initiatingMessage->value.present = \
8497                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
8498       initULRRCMsg =\
8499                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
8500       elementCnt = 5;
8501       initULRRCMsg->protocolIEs.list.count = elementCnt;
8502       initULRRCMsg->protocolIEs.list.size = \
8503                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
8504       /* Initialize the F1Setup members */
8505       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
8506       if(initULRRCMsg->protocolIEs.list.array == NULLP)
8507       {
8508          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
8509                RRCSetupRequestMessageTransferIEs failed");
8510          break;
8511       }
8512       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
8513       {
8514          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
8515                sizeof(InitialULRRCMessageTransferIEs_t));
8516          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
8517          {
8518             break;
8519          }
8520       }
8521       ieIdx = 0;
8522       /*GNB DU UE F1AP ID*/
8523       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8524                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8525       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
8526       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8527                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
8528       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
8529
8530
8531       /*NRCGI*/
8532       ieIdx++;
8533       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8534                                                         ProtocolIE_ID_id_NRCGI;
8535       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
8536       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8537                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
8538
8539       ret =\
8540            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
8541       if(ret!=ROK)
8542       {
8543          break;
8544       }
8545
8546       /*CRNTI*/
8547       ieIdx++;
8548       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8549                                                         ProtocolIE_ID_id_C_RNTI;
8550       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8551       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8552                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
8553       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
8554
8555       /*RRCContainer*/
8556       ieIdx++;
8557       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8558                                                         ProtocolIE_ID_id_RRCContainer;
8559       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8560       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8561                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
8562
8563       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
8564       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
8565             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
8566       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8567       {
8568          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
8569          break;
8570
8571       }
8572       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
8573             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8574
8575
8576       /*DUtoCURRCContainer*/
8577       ieIdx++;
8578       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
8579       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8580       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8581                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
8582
8583       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
8584       {
8585          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
8586          {
8587             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
8588                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
8589             {
8590                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
8591             }
8592          }
8593       }
8594
8595       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
8596       if(ret != ROK)
8597       {
8598          break;
8599       }
8600
8601       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8602
8603       /* Encode the Intial UL RRC Message transfer as APER */
8604       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8605       encBufSize = 0;
8606       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
8607       /* Encode results */
8608       if(encRetVal.encoded == ENCODE_FAIL)
8609       {
8610          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
8611                structure (at %s)\n",encRetVal.failed_type ? \
8612                encRetVal.failed_type->name : "unknown");
8613          ret = RFAILED;
8614          break;
8615       }
8616       else
8617       {
8618
8619          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
8620                Message transfer\n");
8621          for(int i=0; i< encBufSize; i++)
8622          {
8623             printf("%x",encBuf[i]);
8624          }
8625       }
8626       /* Sending  msg  */
8627       if(sendF1APMsg() != ROK)
8628       {
8629          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
8630          ret = RFAILED;
8631          break;
8632       }
8633       break;
8634    }
8635    freeInitUlRrcMsgTransfer(f1apMsg);
8636    return ret;
8637 }/* End of BuildAndSendInitialRrcMsgTransfer*/
8638
8639 /*****  UE SETUP REQUEST *****/
8640
8641 /*******************************************************************
8642  *
8643  * @brief Free Qos And Snssai Drb Info
8644  *
8645  * @details
8646  *
8647  *    Function : freeDrbQosAndSnssaiInfo
8648  *
8649  *    Functionality: Free Qos And Snssai Drb Info
8650  *
8651  * @params[in] LcCfg *lcCfg,
8652  * @return void
8653  *
8654  * ****************************************************************/
8655 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
8656 {
8657    if(lcCfg->snssai)
8658    {
8659       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8660    }
8661    if(lcCfg->drbQos)
8662    {
8663       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
8664    }
8665 }
8666
8667 /******************************************************************
8668 *
8669 * @brief Function to delete the RLC Lc cfg from UE APP DB
8670 *
8671 * @details
8672 *
8673 *  Function : freeRlcLcCfg
8674 *
8675 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
8676 *
8677 *
8678  *****************************************************************/
8679
8680 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
8681 {
8682    switch(lcCfg->rlcMode)
8683    {
8684       case RLC_AM :
8685          {
8686             if(lcCfg->u.amCfg)
8687             {
8688                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
8689             }
8690             break;
8691          }
8692       case RLC_UM_BI_DIRECTIONAL :
8693          {
8694             if(lcCfg->u.umBiDirCfg)
8695             {
8696                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8697             }
8698             break;
8699          }
8700       case RLC_UM_UNI_DIRECTIONAL_UL :
8701          {
8702             if(lcCfg->u.umUniDirUlCfg)
8703             {
8704                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8705             }
8706             break;
8707
8708          }
8709       case RLC_UM_UNI_DIRECTIONAL_DL :
8710          {
8711             if(lcCfg->u.umUniDirDlCfg)
8712             {
8713                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8714             }
8715             break;
8716          }
8717       default:
8718          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
8719          break;
8720    }
8721    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8722 }
8723
8724 /*******************************************************************
8725  *
8726  * @brief Function to free MacLcCfg
8727  *
8728  * @details
8729  *
8730  *    Function : freeMacLcCfg
8731  *
8732  *    Functionality: Function to free MacLcCfg
8733  *
8734  * @params[in] LcCfg *lcCfg,
8735  * @return void
8736  *
8737  * ****************************************************************/
8738
8739 void  freeMacLcCfg(LcCfg *lcCfg)
8740 {
8741     /* Deleting DRBQOS */
8742    if(lcCfg->drbQos)
8743    {
8744       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
8745    }
8746    /* Deleting SNSSAI */
8747    if(lcCfg->snssai)
8748    {
8749       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8750    }
8751 }
8752 /*******************************************************************
8753  *
8754  * @brief Free UE NR Capability received in UE Context setup request
8755  *
8756  * @details
8757  *
8758  *    Function : freeAperDecodeUeNrCapability
8759  *
8760  *    Functionality:
8761  *       Free UE NR Capability received in UE Context setup request
8762  *
8763  * @params[in]
8764  * @return ROK     - success
8765  *         RFAILED - failure
8766  *
8767  * ****************************************************************/
8768 void freeAperDecodeUeNrCapability(void *ueNrCapability)
8769 {
8770    uint8_t arrIdx =0;
8771    FeatureSets_t *featureSets =NULLP;
8772    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
8773
8774    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
8775    {
8776       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
8777       {
8778          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
8779             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
8780       }
8781       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
8782    }
8783
8784    if(ueNrCap->featureSets)
8785    {
8786       featureSets = ueNrCap->featureSets;
8787       if(featureSets->featureSetsDownlinkPerCC)
8788       {
8789          if(featureSets->featureSetsDownlinkPerCC->list.array)
8790          {
8791             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
8792             {
8793                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
8794                {
8795                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
8796                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
8797                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
8798                }
8799             }
8800             free(featureSets->featureSetsDownlinkPerCC->list.array);
8801          }
8802          free(featureSets->featureSetsDownlinkPerCC);
8803       }
8804       if(featureSets->featureSetsUplinkPerCC)
8805       {
8806          if(featureSets->featureSetsUplinkPerCC->list.array)
8807          {
8808             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
8809             {
8810                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
8811                {
8812                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
8813                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
8814                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
8815                }
8816             }
8817             free(featureSets->featureSetsUplinkPerCC->list.array);
8818          }
8819          free(featureSets->featureSetsUplinkPerCC);
8820       }
8821       free(ueNrCap->featureSets);
8822    }
8823 }
8824
8825 /*******************************************************************
8826 *
8827 * @brief Function to free PdcchSearchSpcToAddModList
8828          where memory allocated by aper_decoder
8829 *
8830 * @details
8831 *
8832 *    Function : freeAperDecodePdcchSearchSpcToAddModList
8833 *
8834 *    Functionality: Function to free PdcchSearchSpcToAddModList
8835 *
8836 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
8837 * @return void
8838 *
8839 * ****************************************************************/
8840
8841 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
8842 {
8843    uint8_t searchSpcArrIdx=0;
8844    uint8_t searchSpcArrIdx1=0;
8845    struct  SearchSpace *searchSpc=NULLP;
8846
8847
8848    if(searchSpcList->list.array)
8849    {
8850       if(searchSpcList->list.array[searchSpcArrIdx1])
8851       {
8852          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
8853          if(searchSpc->controlResourceSetId)
8854          {
8855             if(searchSpc->monitoringSlotPeriodicityAndOffset)
8856             {
8857                if(searchSpc->monitoringSymbolsWithinSlot)
8858                {
8859                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
8860                   {
8861                      if(searchSpc->nrofCandidates)
8862                      {
8863                         if(searchSpc->searchSpaceType)
8864                         {
8865                            free(searchSpc->searchSpaceType->choice.ue_Specific);
8866                            free(searchSpc->searchSpaceType);
8867                         }
8868                         free(searchSpc->nrofCandidates);
8869                      }
8870                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
8871                   }
8872                   free(searchSpc->monitoringSymbolsWithinSlot);
8873                }
8874                free(searchSpc->monitoringSlotPeriodicityAndOffset);
8875             }
8876             free(searchSpc->controlResourceSetId);
8877          }
8878       }
8879       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
8880       {
8881          free(searchSpcList->list.array[searchSpcArrIdx]);
8882       }
8883       free(searchSpcList->list.array);
8884    }
8885 }
8886 /*******************************************************************
8887 *
8888 * @brief Function for free part for the memory allocated by aper_decoder
8889 *
8890 * @details
8891 *
8892 *    Function : freeAperDecodeBWPDlDedPdcchConfig
8893 *
8894 *    Functionality: Function to free BWPDlDedPdcchConfig
8895 *
8896 * @params[in]
8897 * @return void
8898 *
8899 * ****************************************************************/
8900
8901
8902 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
8903 {
8904    uint8_t arrIdx1=0;
8905    uint8_t arrIdx2=0;
8906    struct PDCCH_Config *pdcchCfg=NULLP;
8907    struct ControlResourceSet *controlRSet=NULLP;
8908    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
8909
8910    if(dlBwp->pdcch_Config->choice.setup)
8911    {
8912       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
8913       if(pdcchCfg->controlResourceSetToAddModList)
8914       {
8915          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
8916          if(controlRSetList->list.array)
8917          {
8918             controlRSet = controlRSetList->list.array[arrIdx2];
8919             if(controlRSet)
8920             {
8921                if(controlRSet->frequencyDomainResources.buf)
8922                {
8923                   if(controlRSet->pdcch_DMRS_ScramblingID)
8924                   {
8925                      if(pdcchCfg->searchSpacesToAddModList)
8926                      {
8927                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
8928                         free(pdcchCfg->searchSpacesToAddModList);
8929                      }
8930                      free(controlRSet->pdcch_DMRS_ScramblingID);
8931                   }
8932                   free(controlRSet->frequencyDomainResources.buf);
8933                }
8934             }
8935             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
8936             {
8937                free(controlRSetList->list.array[arrIdx1]);
8938             }
8939             free(controlRSetList->list.array);
8940          }
8941          free(pdcchCfg->controlResourceSetToAddModList);
8942       }
8943       free(dlBwp->pdcch_Config->choice.setup);
8944    }
8945 }
8946 /*******************************************************************
8947 *
8948 * @brief Function to free PdschTimeDomAllocationList
8949 *     where the memory allocated by aper_decoder
8950 *
8951 * @details
8952 *
8953 *    Function : freeAperDecodePdschTimeDomAllocationList
8954 *
8955 *    Functionality: Function to free PdschTimeDomAllocationList
8956 *
8957 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
8958 * @return void
8959 *
8960 * ****************************************************************/
8961
8962
8963 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
8964 {
8965    uint8_t arrIdx=0;
8966
8967    if(timeDomAllocList->choice.setup)
8968    {
8969       if(timeDomAllocList->choice.setup->list.array)
8970       {
8971          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
8972          {
8973             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
8974          }
8975          free(timeDomAllocList->choice.setup->list.array);
8976       }
8977       free(timeDomAllocList->choice.setup);
8978    }
8979 }
8980
8981 /*******************************************************************
8982 *
8983 * @brief Function to free BWPDlDedPdschConfig
8984 *        where the memory allocated by aper_decoder
8985 *
8986 * @details
8987 *
8988 *    Function : freeAperDecodeBWPDlDedPdschConfig
8989 *
8990 *    Functionality: Function to free BWPDlDedPdschConfig
8991 *
8992 * @params[in] BWP_DownlinkDedicated_t *dlBwp
8993 * @return void
8994 *
8995 * ****************************************************************/
8996
8997
8998 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
8999 {
9000    struct PDSCH_Config *pdschCfg=NULLP;
9001    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
9002    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
9003    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
9004
9005    if(dlBwp->pdsch_Config->choice.setup)
9006    {
9007       pdschCfg=dlBwp->pdsch_Config->choice.setup;
9008       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9009       {
9010          if(pdschCfg->pdsch_TimeDomainAllocationList)
9011          {
9012             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
9013             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
9014             {
9015                prbBndlType=&pdschCfg->prb_BundlingType;
9016                free(prbBndlType->choice.staticBundling);
9017                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
9018             }
9019             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
9020             free(pdschCfg->pdsch_TimeDomainAllocationList);
9021          }
9022          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
9023          if(dmrsDlCfg->choice.setup)
9024          {
9025             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
9026             free(dmrsDlCfg->choice.setup);
9027          }
9028          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
9029       }
9030       free(dlBwp->pdsch_Config->choice.setup);
9031    }
9032 }
9033 /*******************************************************************
9034 *
9035 * @brief Function to free PuschTimeDomAllocListCfg
9036                  where the memory allocated by aper_decoder
9037 *
9038 * @details
9039 *
9040 *    Function : freeAperDecodePuschTimeDomAllocListCfg
9041 *
9042 *    Functionality: Function to free PuschTimeDomAllocListCfg
9043 *
9044 * @params[in] PUSCH_Config_t *puschCfg
9045 * @return void
9046 *
9047 * ****************************************************************/
9048
9049
9050 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
9051 {
9052    uint8_t arrIdx=0;
9053    uint8_t arrIdx1=0;
9054    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
9055
9056    if(puschCfg->pusch_TimeDomainAllocationList)
9057    {
9058       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
9059       if(timeDomAllocList_t->choice.setup)
9060       {
9061          if(timeDomAllocList_t->choice.setup->list.array)
9062          {
9063             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
9064             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
9065             {
9066                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
9067             }
9068             free(timeDomAllocList_t->choice.setup->list.array);
9069          }
9070          free(timeDomAllocList_t->choice.setup);
9071       }
9072       free(puschCfg->transformPrecoder);
9073       free(puschCfg->pusch_TimeDomainAllocationList);
9074    }
9075 }
9076 /*******************************************************************
9077 *
9078 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
9079 *
9080 * @details
9081 *
9082 *    Function : freeAperDecodeInitialUlBWPConfig
9083 *
9084 *    Functionality: Function to free InitialUlBWPConfig
9085 *
9086 * @params[in]  BWP_UplinkDedicated_t *ulBwp
9087 * @return void
9088 *
9089 * ****************************************************************/
9090
9091
9092 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
9093 {
9094    uint8_t  rSetIdx =0;
9095    uint8_t  rsrcIdx =0;
9096    SRS_Config_t   *srsCfg = NULLP;
9097    PUSCH_Config_t *puschCfg = NULLP;
9098    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
9099    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
9100    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
9101    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
9102
9103    if(ulBwp->pusch_Config)
9104    {
9105       if(ulBwp->pusch_Config->choice.setup)
9106       {
9107          puschCfg=ulBwp->pusch_Config->choice.setup;
9108          if(puschCfg->dataScramblingIdentityPUSCH)
9109          {
9110             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
9111             {
9112                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
9113                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
9114                if(dmrsUlCfg->choice.setup)
9115                {
9116                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
9117                   {
9118                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
9119                      {
9120                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
9121                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
9122                      }
9123                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
9124                   }
9125                   free(dmrsUlCfg->choice.setup);
9126                }
9127                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
9128             }
9129             free(puschCfg->dataScramblingIdentityPUSCH);
9130          }
9131          free(ulBwp->pusch_Config->choice.setup);
9132       }
9133       free(ulBwp->pusch_Config);
9134
9135       /* Free SRS-Config */
9136       if(ulBwp->srs_Config)
9137       {
9138          if(ulBwp->srs_Config->choice.setup)
9139          {
9140             srsCfg = ulBwp->srs_Config->choice.setup;
9141
9142             /* Free Resource Set to add/mod list */
9143             if(srsCfg->srs_ResourceSetToAddModList)
9144             {
9145                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
9146                if(rsrcSetList->list.array)
9147                {
9148                   rSetIdx = 0;
9149
9150                   /* Free SRS resource Id list in this SRS resource set */
9151                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
9152                   {
9153                      rsrcIdList =
9154                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
9155
9156                      if(rsrcIdList->list.array)
9157                      {
9158                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
9159                               rsrcIdx++)
9160                         {
9161                            free(rsrcIdList->list.array[rsrcIdx]);
9162                         }
9163                         free(rsrcIdList->list.array);
9164                      }
9165                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
9166                   }
9167
9168                   /* Free resource type info for this SRS resource set */
9169
9170                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
9171
9172                   /* Free memory for each resource set */
9173                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
9174                   {
9175                      free(rsrcSetList->list.array[rSetIdx]);
9176                   }
9177                   free(rsrcSetList->list.array);
9178                }
9179                free(srsCfg->srs_ResourceSetToAddModList);
9180             }
9181
9182             /* Free resource to add/modd list */
9183             if(srsCfg->srs_ResourceToAddModList)
9184             {
9185                resourceList = srsCfg->srs_ResourceToAddModList;
9186                if(resourceList->list.array)
9187                {
9188                   rsrcIdx = 0;
9189
9190                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
9191                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
9192
9193                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
9194                   {
9195                      free(resourceList->list.array[rsrcIdx]);
9196                   }
9197                   free(resourceList->list.array);
9198                }
9199                free(srsCfg->srs_ResourceToAddModList);
9200             }
9201
9202             free(ulBwp->srs_Config->choice.setup);
9203          }
9204          free(ulBwp->srs_Config);
9205       }
9206    }
9207 }
9208 /*******************************************************************
9209 *
9210 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
9211 *
9212 * @details
9213 *
9214 *    Function : freeAperDecodeinitialUplinkBWPConfig
9215 *
9216 *    Functionality: Function to free initialUplinkBWPConfig
9217 *
9218 * @params[in] UplinkConfig_t *ulCfg
9219 * @return void
9220 *
9221 * ****************************************************************/
9222
9223
9224 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
9225 {
9226    BWP_UplinkDedicated_t *ulBwp=NULLP;
9227    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
9228
9229    if(ulCfg->initialUplinkBWP)
9230    {
9231       ulBwp=ulCfg->initialUplinkBWP;
9232       if(ulCfg->firstActiveUplinkBWP_Id)
9233       {
9234          if(ulCfg->pusch_ServingCellConfig)
9235          {
9236             puschCfg=ulCfg->pusch_ServingCellConfig;
9237             if(puschCfg->choice.setup)
9238             {
9239                if(puschCfg->choice.setup->ext1)
9240                {
9241                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
9242                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
9243                   free(puschCfg->choice.setup->ext1);
9244                }
9245                free(puschCfg->choice.setup);
9246             }
9247             free(ulCfg->pusch_ServingCellConfig);
9248          }
9249          free(ulCfg->firstActiveUplinkBWP_Id);
9250       }
9251       freeAperDecodeInitialUlBWPConfig(ulBwp);
9252       free(ulCfg->initialUplinkBWP);
9253    }
9254 }
9255
9256 /*******************************************************************
9257  *
9258  * @brief Function to free DuUeCfg
9259  *
9260  * @details
9261  *
9262  *    Function : freeDuUeCfg
9263  *
9264  *    Functionality: Function to free DuUeCfg
9265  *
9266  * @params[in] DuUeCfg *ueCfg
9267  * @return void
9268  *
9269  * ****************************************************************/
9270 void freeDuUeCfg(DuUeCfg *ueCfg)
9271 {
9272    uint8_t lcIdx = 0;
9273    uint8_t arrIdx = 0;
9274    SpCellConfig_t *spCellCfg = NULLP;
9275    ServingCellConfig_t *srvCellCfg = NULLP;
9276    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9277    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
9278    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9279    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
9280    struct RLC_Config *rlcConfig = NULLP;
9281    struct LogicalChannelConfig *macLcConfig = NULLP;
9282    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
9283    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
9284    struct TAG_Config *tagConfig = NULLP;
9285    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
9286    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
9287    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
9288    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
9289
9290    if(ueCfg->ueNrCapability)
9291    {
9292       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
9293       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
9294       ueCfg->ueNrCapability = NULLP;
9295    }
9296
9297    if(ueCfg->cellGrpCfg)
9298    {
9299
9300       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
9301       if(rlcBearerList)
9302       {
9303          if(rlcBearerList->list.array)
9304          {
9305             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
9306             {
9307                if(rlcBearerList->list.array[arrIdx])
9308                {
9309                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
9310                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
9311
9312                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
9313                   {
9314                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
9315                   }
9316                   if(rlcConfig)
9317                   {
9318                      if(rlcConfig->choice.am)
9319                      {
9320                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
9321                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
9322                         free(rlcConfig->choice.am);
9323                      }
9324                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
9325                   }
9326                   if(macLcConfig)
9327                   {
9328                      if(macLcConfig->ul_SpecificParameters)
9329                      {
9330                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
9331                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
9332                         free(macLcConfig->ul_SpecificParameters);
9333                      }
9334                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
9335                   }
9336                   free(rlcBearerList->list.array[arrIdx]);
9337                }
9338             }
9339             free(rlcBearerList->list.array);
9340          }
9341          free(cellGrpCfg->rlc_BearerToAddModList);
9342       }
9343
9344       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
9345       if(macCellGrpCfg)
9346       {
9347          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
9348          if(schedulingRequestConfig)
9349          {
9350             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
9351             if(schReqList)
9352             {
9353                if(schReqList->list.array)
9354                {
9355                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
9356                   {
9357                      if(schReqList->list.array[arrIdx])
9358                      {
9359                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
9360                         free(schReqList->list.array[arrIdx]);
9361                      }
9362                   }
9363                   free(schReqList->list.array);
9364                }
9365                free(schedulingRequestConfig->schedulingRequestToAddModList);
9366             }
9367             free(macCellGrpCfg->schedulingRequestConfig);
9368          }
9369          if(macCellGrpCfg->bsr_Config)
9370          {
9371             free(macCellGrpCfg->bsr_Config);
9372          }
9373          tagConfig = macCellGrpCfg->tag_Config;
9374          if(tagConfig)
9375          {
9376             tagList = tagConfig->tag_ToAddModList;
9377             if(tagList)
9378             {
9379                if(tagList->list.array)
9380                {
9381                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
9382                   {
9383                      free(tagList->list.array[arrIdx]);
9384                   }
9385                   free(tagList->list.array);
9386                }
9387                free(tagConfig->tag_ToAddModList);
9388             }
9389             free(tagConfig);
9390          }
9391
9392          phrConfig = macCellGrpCfg->phr_Config;
9393          if(phrConfig)
9394          {
9395             free(phrConfig->choice.setup);
9396             free(phrConfig);
9397          }
9398
9399          free(macCellGrpCfg);
9400       }
9401
9402       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
9403       if(phyCellGrpCfg)
9404       {
9405          free(phyCellGrpCfg->p_NR_FR1);
9406          free(phyCellGrpCfg);
9407       }
9408
9409       spCellCfg = cellGrpCfg->spCellConfig;
9410       if(spCellCfg)
9411       {
9412          if(spCellCfg->servCellIndex)
9413          {
9414             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
9415             {
9416                if(spCellCfg->spCellConfigDedicated)
9417                {
9418                   srvCellCfg = spCellCfg->spCellConfigDedicated;
9419                   if(srvCellCfg->initialDownlinkBWP)
9420                   {
9421                      dlBwp = srvCellCfg->initialDownlinkBWP;
9422                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
9423                      {
9424                         if(srvCellCfg->defaultDownlinkBWP_Id)
9425                         {
9426                            if(srvCellCfg->uplinkConfig)
9427                            {
9428
9429                               if(srvCellCfg->pdsch_ServingCellConfig)
9430                               {
9431                                  pdschCfg=
9432                                     srvCellCfg->pdsch_ServingCellConfig;
9433                                  if(pdschCfg->choice.setup)
9434                                  {
9435
9436                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
9437                                     free(pdschCfg->choice.setup);
9438                                  }
9439
9440                                  free(srvCellCfg->pdsch_ServingCellConfig);
9441                               }
9442
9443                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
9444                               free(srvCellCfg->uplinkConfig);
9445                            }
9446                            free(srvCellCfg->defaultDownlinkBWP_Id);
9447                         }
9448
9449                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
9450                      }
9451                      if(dlBwp->pdcch_Config)
9452                      {
9453                         if(dlBwp->pdsch_Config)
9454                         {
9455                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
9456                            free(dlBwp->pdsch_Config);
9457                         }
9458                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
9459                         free(dlBwp->pdcch_Config);
9460                      }
9461                      free(srvCellCfg->initialDownlinkBWP);
9462                   }
9463
9464                   free(spCellCfg->spCellConfigDedicated);
9465                }
9466                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
9467             }
9468             free(spCellCfg->servCellIndex);
9469          }
9470          free(spCellCfg);
9471       }
9472       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9473       ueCfg->cellGrpCfg = NULLP;
9474    }
9475    if(ueCfg->ambrCfg)
9476    {
9477       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
9478    }
9479    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
9480    {
9481       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
9482    }
9483    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
9484    {
9485       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
9486    }
9487    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
9488    {
9489       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
9490    }
9491 }
9492
9493 /*******************************************************************
9494  *
9495  * @brief Function to free UecontextSetupDb
9496  *
9497  * @details
9498  *
9499  *    Function : freeF1UeDb
9500  *
9501  *    Functionality: Function to free UecontextSetupDb
9502  *
9503  * @params[in] UecontextSetupDb *
9504  * @return void
9505  *
9506  * ****************************************************************/
9507
9508 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
9509 {
9510
9511    if(f1UeDb->dlRrcMsg)
9512    {
9513       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
9514       {
9515         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
9516                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
9517       }
9518       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
9519    }
9520    freeDuUeCfg(&f1UeDb->duUeCfg);
9521    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
9522    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
9523 }
9524
9525 /*******************************************************************
9526  *
9527  * @brief Function to build Am cfg Info
9528  *
9529  * @details
9530  *
9531  *    Function : extractRlcAmCfg
9532  *
9533  *    Functionality: Function to build Am cfg Info
9534  *
9535  * @params[in] AmBearerCfg *
9536  *             void *
9537  *
9538  * @return ROK/RFAILED
9539  *
9540  * ****************************************************************/
9541
9542 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
9543 {
9544    if(rlcAmCfg)
9545    {
9546       /* UL AM */
9547       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
9548       {
9549          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
9550          /*TODO: Check the timer value when sent by real CU */
9551          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
9552          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
9553       }
9554
9555       /* DL AM */
9556       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
9557       {
9558          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
9559          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
9560          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
9561          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
9562          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
9563       }
9564    }
9565 }
9566
9567 /*******************************************************************
9568  *
9569  * @brief Function to build Um Bi Info
9570  *
9571  * @details
9572  *
9573  *    Function : extractRlcUmBiCfg
9574  *
9575  *    Functionality: Function to build Um Bi Info
9576  *
9577  * @params[in] UmBiDirBearerCfg *
9578  *             void *
9579  *
9580  * @return ROK/RFAILED
9581  *
9582  * ****************************************************************/
9583
9584 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
9585 {
9586    if(rlcBiCfg)
9587    {
9588       /* UL UM BI DIR Cfg */
9589       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
9590       {
9591          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
9592          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
9593       }
9594
9595       /* DL UM BI DIR Cfg */
9596       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
9597          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
9598    }
9599 }
9600
9601 /*******************************************************************
9602  *
9603  * @brief Function to build Um Ul Info
9604  *
9605  * @details
9606  *
9607  *    Function : extractRlcUmUlCfg
9608  *
9609  *    Functionality: Function to build Um Ul Info
9610  *
9611  * @params[in] UmUniDirUlBearerCfg *
9612  *             void *
9613  *
9614  * @return ROK/RFAILED
9615  *
9616  * ****************************************************************/
9617
9618 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
9619 {
9620    if(umUlCfg)
9621    {
9622       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
9623       {
9624          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
9625          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
9626       }
9627    }
9628 }
9629
9630 /*******************************************************************
9631  *
9632  * @brief Function to build Um Uni Dl Info
9633  *
9634  * @details
9635  *
9636  *    Function : extractRlcUmDlCfg
9637  *
9638  *    Functionality: Function to build Um Uni Dl Info
9639  *
9640  * @params[in] UmUniDirDlBearerCfg *
9641  *             void *
9642  *
9643  * @return ROK/RFAILED
9644  *
9645  * ****************************************************************/
9646 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
9647 {
9648    if(umDlCfg)
9649    {
9650       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
9651          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
9652    }
9653 }
9654
9655 /*******************************************************************
9656  *
9657  * @brief Function to extractRlcModeCfg
9658  *
9659  * @details
9660  *
9661  *    Function : extractRlcModeCfg
9662  *
9663  *    Functionality: Function to extractRlcModeCfg
9664  *
9665  * @params[in] RLC_Config_t *
9666  *             RlcBearerCfg *
9667  *             void  *
9668  * @return ROK/RFAILED
9669  *
9670  * ****************************************************************/
9671 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
9672 {
9673    if(lcCfg)
9674    {
9675       switch(rlcMode)
9676       {
9677          case RLC_AM :
9678             {
9679                if(lcCfg->choice.am)
9680                {
9681                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
9682                   if(rlcDbCfg->u.amCfg)
9683                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
9684                }
9685                break;
9686             }
9687          case RLC_UM_BI_DIRECTIONAL :
9688             {
9689                if(lcCfg->choice.um_Bi_Directional)
9690                {
9691                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
9692                   if(rlcDbCfg->u.umBiDirCfg)
9693                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
9694                }
9695                break;
9696             }
9697          case RLC_UM_UNI_DIRECTIONAL_UL :
9698             {
9699                if(lcCfg->choice.um_Uni_Directional_DL)
9700                {
9701                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
9702                   if(rlcDbCfg->u.umUniDirUlCfg)
9703                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
9704                }
9705                break;
9706             }
9707          case RLC_UM_UNI_DIRECTIONAL_DL :
9708             {
9709                if(lcCfg->choice.um_Uni_Directional_UL)
9710                {
9711                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
9712                   if(rlcDbCfg->u.umUniDirDlCfg)
9713                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
9714                }
9715                break;
9716             }
9717          default:
9718             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
9719             break;
9720       }
9721    }
9722 }
9723
9724 /*******************************************************************
9725  *
9726  * @brief Function to extract extractUlLcCfg
9727  *
9728  * @details
9729  *
9730  *    Function : extractUlLcCfg
9731  *
9732  *    Functionality: Function to extract extractUlLcCfg
9733  *
9734  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
9735  * @return void
9736  *
9737  * ****************************************************************/
9738
9739 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
9740 {
9741    if(ulLcCfg)
9742    {
9743       if(ulLcCfg->ul_SpecificParameters)
9744       {
9745          f1UlLcCfg->priority = \
9746             ulLcCfg->ul_SpecificParameters->priority;
9747       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
9748       {
9749          f1UlLcCfg->lcGroup = \
9750            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
9751       }
9752       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
9753       {
9754          f1UlLcCfg->schReqId = \
9755            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
9756       }
9757       f1UlLcCfg->pbr = \
9758          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
9759       f1UlLcCfg->bsd = \
9760          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
9761       }
9762    }
9763 }
9764
9765 /*******************************************************************
9766 *
9767 * @brief Function to extract Snssai Cfg Info from CU
9768 *
9769 * @details
9770 *
9771 *    Function : extractDrbSnssaiCfg
9772 *
9773 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
9774 *
9775 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
9776 * @return ROK/RFAILED
9777 *
9778 * ****************************************************************/
9779
9780 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
9781 {
9782    if(!(*snssaiToBeShared))
9783    {
9784       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
9785       if(snssaiToBeShared == NULLP)
9786       {
9787          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
9788          return RFAILED;
9789       }
9790    }
9791    if(RecvSnssai)
9792    {
9793       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
9794       if(RecvSnssai->sD)
9795       {
9796          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
9797       }
9798       else
9799       {
9800          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
9801          return RFAILED;
9802       }
9803    }
9804    return ROK;
9805 }
9806
9807 /*******************************************************************
9808  *
9809  * @brief Function to procRlcLcCfg
9810  *
9811  * @details
9812  *
9813  *    Function : procRlcLcCfg
9814  *
9815  *    Functionality: Function to procRlcLcCfg
9816  *
9817  * @params[in] rbId, lcId, rbType, rlcMod
9818  *             RLC_Config_t *, RlcBearerCfg * ,
9819  * @return void
9820  *
9821  * ****************************************************************/
9822
9823 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
9824    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
9825 {
9826    DRB_Information_t *drbInfo;
9827
9828    lcCfg->rbId   = rbId;
9829    lcCfg->configType = configType;
9830
9831    if(rbType == RB_TYPE_SRB)
9832    {
9833       lcCfg->rbType = RB_TYPE_SRB;
9834       lcCfg->lcId   = rbId;
9835       lcCfg->lcType = LCH_DCCH;
9836       lcCfg->rlcMode = RLC_AM;
9837    }
9838    else if(rbType == RB_TYPE_DRB)
9839    {
9840       lcCfg->rbType = RB_TYPE_DRB;
9841       lcCfg->lcId   = lcId;
9842       lcCfg->lcType = LCH_DTCH;
9843       lcCfg->rlcMode = rlcMode;
9844    }
9845    if(f1RlcCfg) /* rlc mode config recived */
9846    {
9847       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
9848    }
9849    if(qoSInformation != NULLP)
9850    {
9851       if(qoSInformation->present == QoSInformation_PR_choice_extension)
9852       {
9853          if(qoSInformation->choice.choice_extension->value.present ==\
9854                QoSInformation_ExtIEs__value_PR_DRB_Information)
9855          {
9856             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
9857             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
9858             {
9859                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
9860                return;
9861             }
9862          }
9863       }
9864    }
9865 }
9866
9867 /*******************************************************************
9868  *
9869  * @brief Fills DrbQos Info received by CU
9870  *
9871  * @details
9872  *
9873  *    Function : extractQosInfo
9874  *
9875  *    Functionality: Fills DrbQos Info received  by CU
9876  *
9877  * @params[in] DrbQosInfo *qosToAdd,
9878  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
9879  * @return void
9880  *
9881  * ****************************************************************/
9882
9883 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
9884 {
9885    uint8_t qosCntIdx = 0;
9886    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
9887
9888    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
9889    qosToAdd->u.nonDyn5Qi.fiveQi     =\
9890                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
9891    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
9892    {
9893       qosToAdd->u.nonDyn5Qi.avgWindow = \
9894                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9895    }
9896
9897    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
9898    {
9899       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
9900                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9901    }
9902
9903    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
9904    {
9905       qosToAdd->u.nonDyn5Qi.priorLevel = \
9906                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
9907    }
9908    qosToAdd->ngRanRetPri.priorityLevel = \
9909                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
9910    qosToAdd->ngRanRetPri.preEmptionCap = \
9911                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
9912    qosToAdd->ngRanRetPri.preEmptionVul = \
9913                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
9914    if(qosFlowCfg->gBR_QoS_Flow_Information)
9915    {
9916       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
9917             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
9918             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
9919       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
9920             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
9921             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
9922       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
9923             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
9924             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
9925       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
9926             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
9927             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
9928    }
9929    /*Extracting PDU_SESSION_ID*/
9930    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
9931    if(qosIeExt)
9932    {
9933       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
9934       {
9935          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
9936                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
9937          {
9938             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
9939             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
9940          }
9941       }
9942    }
9943    qosToAdd->ulPduSessAggMaxBitRate = 0;
9944 }
9945
9946 /*******************************************************************
9947  *
9948  * @brief Function to extract GTP Tunnel Info from CU
9949  *
9950  * @details
9951  *
9952  *    Function : extractUpTnlInfo
9953  *
9954  *    Functionality: Function to extract GTP Tunnel Info from CU
9955  *
9956  * @params[in] F1AP message
9957  * @return ROK/RFAILED
9958  *
9959  * ****************************************************************/
9960
9961 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
9962    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
9963 {
9964    uint8_t tnlIdx;
9965    uint32_t ipv4_du = 0;
9966    GTPTunnel_t *gtpTunnel = NULLP;
9967
9968    upTnlInfo->drbId = drbId;
9969    upTnlInfo->configType = configType;
9970 #ifdef O1_ENABLE
9971    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
9972 #else
9973    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
9974 #endif
9975
9976    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
9977    {
9978       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9979       {
9980          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
9981          {
9982             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
9983             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
9984             if(upTnlInfo->tnlCfg1 == NULLP)
9985             {
9986                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
9987                return RFAILED;
9988             }
9989             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
9990             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
9991             if(gtpTunnel->gTP_TEID.size > 0)
9992             {
9993                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
9994             }
9995          }
9996          break;
9997       }
9998    }
9999    return ROK;
10000 }
10001
10002 /*******************************************************************
10003 *
10004 * @brief Function to extract Drb Qos Cfg Info from CU
10005 *
10006 * @details
10007 *
10008 *    Function : extractDrbQosCfg
10009 *
10010 *    Functionality: Function to extract Drb Qos Cfg Info from CU
10011 *
10012 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
10013 * @return ROK/RFAILED
10014 *
10015 * ****************************************************************/
10016
10017 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
10018 {
10019    if(!macLcToAdd->drbQos)
10020    {
10021       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
10022       if(macLcToAdd->drbQos == NULLP)
10023       {
10024          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
10025          return RFAILED;
10026       }
10027
10028    }
10029    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
10030    {
10031       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
10032       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
10033    }
10034    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
10035    {
10036       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
10037       return RFAILED;
10038    }
10039    return ROK;
10040 }
10041 /*******************************************************************
10042  *
10043  * @brief Function to extract DRB info received from CU
10044  *
10045  * @details
10046  *
10047  *    Function : extractDrbCfg
10048  *
10049  *    Functionality: Function to extract DRB info received from CU
10050  *
10051  * @params[in] F1AP message
10052  * @return void
10053  *
10054  * ****************************************************************/
10055 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
10056 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
10057 {
10058    DRB_Information_t *drbInfo = NULLP;
10059
10060    if(drbItem != NULLP)
10061    {
10062       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
10063       {
10064          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10065          return RFAILED;
10066       }
10067       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10068       {
10069          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
10070          {
10071             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10072             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10073             {
10074                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10075                return RFAILED;
10076             }
10077          }
10078       }
10079    }
10080    else if(drbSetupModItem != NULLP)
10081    {
10082       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
10083       upTnlInfo) != ROK)
10084       {
10085          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10086          return RFAILED;
10087       }
10088       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10089       {
10090          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
10091          QoSInformation_ExtIEs__value_PR_DRB_Information)
10092          {
10093             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10094             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10095             {
10096                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10097                return RFAILED;
10098             }
10099
10100          }
10101       }
10102    }
10103    else if(drbModItem != NULLP)
10104    {
10105       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
10106       upTnlInfo) != ROK)
10107       {
10108          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10109          return RFAILED;
10110       }
10111       if(drbModItem->qoSInformation != NULLP)
10112       {
10113          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
10114          {
10115             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
10116                   QoSInformation_ExtIEs__value_PR_DRB_Information)
10117             {
10118                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10119                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10120                {
10121                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10122                   return RFAILED;
10123                }
10124
10125             }
10126          }
10127       }
10128    }
10129    return ROK;
10130 }
10131
10132 /*******************************************************************
10133  *
10134  * @brief Function to extract RB info received from CU
10135  *
10136  * @details
10137  *
10138  *    Function : extractMacRbCfg
10139  *
10140  *    Functionality: Function to extract RB info received from CU
10141  *
10142  * @params[in] F1AP message
10143  * @return ROK/RFAILED
10144  *
10145  * ****************************************************************/
10146
10147 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
10148 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10149 {
10150    if(drbCfg != NULLP)
10151    {
10152       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
10153       {
10154          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10155          return RFAILED;
10156       }
10157    }
10158    else if(drbSetupModCfg != NULLP)
10159    {
10160       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
10161       {
10162          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10163          return RFAILED;
10164       }
10165    }
10166    else if(drbModCfg != NULLP)
10167    {
10168       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
10169       {
10170          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10171          return RFAILED;
10172       }
10173    }
10174    else
10175    {
10176       lcCfg->drbQos = NULLP;
10177       lcCfg->snssai = NULLP;
10178       if(lcCfg->lcId == SRB2_LCID)
10179          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
10180       else
10181          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
10182    }
10183    if(ulLcCfg)
10184    {
10185       lcCfg->ulLcCfgPres = true;
10186       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
10187    }
10188    else
10189       lcCfg->ulLcCfgPres = false;
10190    return ROK;
10191 }
10192
10193 /*******************************************************************
10194  *
10195  * @brief Function processing LC config info received from CU
10196  *
10197  * @details
10198  *
10199  *    Function : procMacLcCfg
10200  *
10201  *    Functionality: Function processing LC config info received from CU
10202  *
10203  * @params[in] F1AP message
10204  * @return ROK/RFAILED
10205  *
10206  * ****************************************************************/
10207
10208 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
10209 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
10210 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10211 {
10212    uint8_t ret = ROK;
10213
10214    lcCfg->lcId = lcId;
10215    lcCfg->configType = configType;
10216    if(rbType == RB_TYPE_SRB)
10217    {
10218       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
10219    }
10220    else if(rbType == RB_TYPE_DRB)
10221    {
10222       if(drbItem != NULL)
10223         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
10224       else if(drbSetupModItem != NULL)
10225         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
10226       else if(drbModItem != NULL)
10227         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
10228    }
10229    return ret;
10230 }
10231
10232 /*******************************************************************
10233  *
10234  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
10235  *
10236  * @details
10237  *
10238  *    Function : extractRlcCfgToAddMod
10239  *
10240  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
10241  *
10242  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
10243  *             DuUeCfg Pointer
10244  * @return ROK/RFAILED
10245  *
10246  * ****************************************************************/
10247
10248 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
10249 {
10250   uint8_t idx, rbId, lcId, rlcMode, rbType;
10251   RLC_Config_t *f1RlcCfg = NULLP;
10252   LogicalChannelConfig_t *macUlLcCfg = NULLP;
10253
10254   for(idx = 0; idx < lcCfg->list.count; idx++)
10255   {
10256      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
10257      if(lcCfg->list.array[idx]->servedRadioBearer)
10258      {
10259         /* RadioBearer for SRB/DRB */
10260         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10261         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
10262         {
10263            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
10264            rbType = RB_TYPE_SRB;
10265         }
10266         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10267         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
10268         {
10269            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
10270            rbType = RB_TYPE_DRB;
10271         }
10272         else
10273         {
10274            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
10275            return RFAILED;
10276         }
10277         /* MAC UL LC Config */
10278         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
10279         {
10280            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
10281         }
10282      }
10283      else
10284      {
10285         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
10286         return RFAILED;
10287      }
10288      /* RLC Mode Config */
10289      if(lcCfg->list.array[idx]->rlc_Config)
10290      {
10291         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
10292         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
10293      }
10294
10295      /* Filling RLC/MAC Config*/
10296      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
10297      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
10298      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
10299      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
10300      {
10301         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
10302         return RFAILED;
10303      }
10304      (ueCfgDb->numRlcLcs)++;
10305      (ueCfgDb->numMacLcs)++;
10306      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10307         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10308   }
10309   //TODO: To send the failure cause in UeContextSetupRsp
10310   return ROK;
10311 }
10312
10313 /*******************************************************************
10314  *
10315  * @brief DeAlloc pdsch serv cell config info
10316  *
10317  * @details
10318  *
10319  *    Function : freeMacPdschServCellInfo
10320  *
10321  *    Functionality: DeAlloc pdsch serv cell config info
10322  *
10323  * @params[in] PdschServCellCfg pointer
10324  * @return void
10325  *
10326  * ****************************************************************/
10327
10328 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
10329 {
10330    if(pdsch->xOverhead)
10331    {
10332       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
10333    }
10334    if(pdsch->codeBlkGrpFlushInd)
10335    {
10336       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
10337    }
10338    if(pdsch->maxCodeBlkGrpPerTb)
10339    {
10340       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
10341    }
10342    if(pdsch->maxMimoLayers)
10343    {
10344       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
10345    }
10346 }
10347
10348 /*******************************************************************
10349  *
10350  * @brief Free Serving cell Info
10351  *
10352  * @details
10353  *
10354  *    Function : freeMacServingCellInfo
10355  *
10356  *    Functionality: Free Serving cell Info
10357  *
10358  * @params[in] ServCellCfgInfo *srvCellCfg
10359  * @return void
10360  *
10361  * ****************************************************************/
10362 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
10363 {
10364    uint8_t timeDomRsrcIdx;
10365
10366    if(srvCellCfg->initDlBwp.pdschPresent)
10367    {
10368       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
10369       {
10370          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
10371             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
10372       }
10373    }
10374
10375    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
10376    if(srvCellCfg->bwpInactivityTmr)
10377    {
10378       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10379    }
10380
10381    if(srvCellCfg->initUlBwp.pucchPresent)
10382    {
10383       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10384    }
10385 }
10386
10387 /*******************************************************************
10388  *
10389  * @brief Free cell Grp Cfg Info
10390  *
10391  * @details
10392  *
10393  *    Function : freeUeReCfgCellGrpInfo
10394  *
10395  *    Functionality: Free cell Grp Cfg Info
10396  *
10397  * @params[in] MacUeCfg*  duUeCfg
10398  * @return void
10399  *
10400  * ****************************************************************/
10401
10402 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
10403 {
10404    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
10405 }
10406
10407 /*******************************************************************
10408  *
10409  * @brief Fills Reconfig SchReqReConfig
10410  *
10411  * @details
10412  *
10413  *    Function : extractSchReqReConfig
10414  *
10415  *    Functionality: Fills Reconfig SchReqReConfig
10416  *
10417  * @params[in] SchedulingRequestConfig_t *cuSchedReq
10418  *             SchedReqCfg*  macSchedReq
10419  * @return void
10420  *
10421  * ****************************************************************/
10422 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
10423 {
10424    uint8_t schReqIdx = 0;
10425    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
10426    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
10427
10428    if(cuSchedReq->schedulingRequestToAddModList)
10429    {
10430       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
10431       if(schReqListToAdd->list.count)
10432       {
10433          macSchedReq->addModListCount = schReqListToAdd->list.count;
10434          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
10435          {
10436             macSchedReq->addModList[schReqIdx].schedReqId = \
10437                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
10438             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
10439                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
10440             macSchedReq->addModList[schReqIdx].srTransMax    =\
10441                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
10442          }
10443       }
10444    }
10445    /* Scheduling Req To release */
10446    if(cuSchedReq->schedulingRequestToReleaseList)
10447    {
10448       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
10449       if(schReqListToRel->list.count)
10450       {
10451          macSchedReq->relListCount = schReqListToRel->list.count;
10452          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
10453          {
10454             macSchedReq->relList[schReqIdx] = \
10455                *schReqListToRel->list.array[schReqIdx];
10456          }
10457       }
10458    }
10459 }
10460
10461 /*******************************************************************
10462  *
10463  * @brief Fills TagReconfig
10464  *
10465  * @details
10466  *
10467  *    Function : extractTagReconfig
10468  *
10469  *    Functionality: Fills extractTagReconfig
10470  *
10471  * @params[in] TAG_Config_t *cuTagCfg
10472  *             TagCfg *macTagCfg
10473  * @return void
10474  *
10475  * ****************************************************************/
10476
10477 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
10478 {
10479   uint8_t tagIdx = 0;
10480   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
10481   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
10482
10483   /* Tag config to AddMod */
10484   if(cuTagCfg->tag_ToAddModList)
10485   {
10486      tagListToAddMod = cuTagCfg->tag_ToAddModList;
10487      if(tagListToAddMod->list.count)
10488      {
10489         macTagCfg->addModListCount = tagListToAddMod->list.count;
10490         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
10491         {
10492            macTagCfg->addModList[tagIdx].tagId =\
10493               tagListToAddMod->list.array[tagIdx]->tag_Id;
10494            macTagCfg->addModList[tagIdx].timeAlignTimer = \
10495
10496               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
10497         }
10498      }
10499   }
10500   /* Tag config to release */
10501   if(cuTagCfg->tag_ToReleaseList)
10502   {
10503      tagListToRel = cuTagCfg->tag_ToReleaseList;
10504      if(tagListToRel->list.count)
10505      {
10506         macTagCfg->relListCount = tagListToRel->list.count;
10507         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
10508         {
10509            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
10510         }
10511      }
10512   }
10513 }
10514
10515 /*******************************************************************
10516  *
10517  * @brief Fills PdcchCfg received by CU
10518  *
10519  * @details
10520  *
10521  *    Function : extractPdcchCfg
10522  *
10523  *    Functionality: Fills PdcchCfg received  by CU
10524  *
10525  * @params[in] PDCCH_Config_t *cuPdcchCfg,
10526  *             PdcchConfig *duPdcchCfg
10527  * @return void
10528  *
10529  * ****************************************************************/
10530
10531 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
10532 {
10533    uint8_t cRsetIdx = 0;
10534    uint8_t srchSpcIdx = 0;
10535
10536    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
10537    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
10538    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
10539    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
10540
10541
10542    /* Control Resource Set To Add/Mod List */
10543    if(cuPdcchCfg->controlResourceSetToAddModList)
10544    {
10545       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
10546       if(cRsetToAddModList->list.count)
10547       {
10548          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
10549          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
10550          {
10551             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
10552                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
10553             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
10554                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
10555             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
10556                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
10557                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
10558
10559             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
10560                 cRsetToAddModList->list.array[cRsetIdx]->duration;
10561
10562             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
10563                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
10564             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
10565             {
10566                //TODO: handle the case for Interleaved
10567             }
10568             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
10569                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
10570             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
10571             {
10572                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
10573                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
10574             }
10575          }
10576       }
10577    }
10578    /* Control Resource Set To Release List */
10579    if(cuPdcchCfg->controlResourceSetToReleaseList)
10580    {
10581       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
10582       if(cRsetToRelList->list.count)
10583       {
10584          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
10585          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
10586          {
10587             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
10588          }
10589       }
10590    }
10591
10592    /* Search space To Add/Mod List */
10593    if(cuPdcchCfg->searchSpacesToAddModList)
10594    {
10595       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
10596       if(srchSpcToAddModList->list.count)
10597       {
10598          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
10599          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
10600          {
10601             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
10602                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
10603             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
10604                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
10605             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
10606             {
10607                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
10608                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
10609             }
10610             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
10611             {
10612                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
10613                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
10614             }
10615             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
10616             {
10617                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
10618                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
10619                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
10620                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
10621                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
10622                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
10623
10624                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
10625                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
10626
10627                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
10628                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
10629             }
10630             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
10631             {
10632                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
10633                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
10634                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
10635                {
10636                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
10637                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
10638                }
10639
10640             }
10641          }
10642       }
10643    }
10644    /* Search space To Rel List */
10645    if(cuPdcchCfg->searchSpacesToReleaseList)
10646    {
10647       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
10648       if(srchSpcToRelList->list.count)
10649       {
10650          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
10651          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
10652          {
10653             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
10654                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
10655          }
10656       }
10657    }
10658 }
10659
10660 /*******************************************************************
10661  *
10662  * @brief Fills PdschCfg received by CU
10663  *
10664  * @details
10665  *
10666  *    Function : extractPdschCfg
10667  *
10668  *    Functionality: Fills PdschCfg received  by CU
10669  *
10670  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
10671  *                   which we have stored in F1UeContextSetupDb,
10672  *             PdschConfig *macPdschCfg = Used to Store the information which
10673  *                   needs to send in other layer, as well as this can be the variable
10674  *                   which stores the information in DuCb,
10675  *             PdschConfig *storedPdschCfg =  Null in case of sending the
10676  *                   information to other layer else it will have stored pdsch
10677  *                   configuration in copyOfmacUeCfg.
10678  * @return void
10679  *
10680  * ****************************************************************/
10681
10682 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
10683 {
10684    uint8_t timeDomIdx;
10685    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
10686
10687    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
10688    {
10689       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
10690             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
10691       {
10692          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
10693          {
10694             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
10695                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
10696          }
10697       }
10698    }
10699    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
10700    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
10701    {
10702       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
10703       if(timeDomAlloc->present ==\
10704             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
10705       {
10706          if(timeDomAlloc->choice.setup)
10707          {
10708             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
10709             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
10710             {
10711                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
10712                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
10713                {
10714                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
10715                   {
10716                      if(storedPdschCfg)
10717                      {
10718                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
10719                         {
10720                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
10721                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
10722                         }
10723                         else
10724                         {
10725                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
10726                         }
10727                      }
10728                      else
10729                      {
10730                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
10731                      }
10732                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
10733                      {
10734                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
10735                         return;
10736                      }
10737                   }
10738                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
10739                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
10740                }
10741                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
10742                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
10743                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
10744                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
10745             }
10746          }
10747       }
10748    }
10749    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
10750    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
10751       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
10752    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
10753    {
10754       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
10755       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
10756       {
10757          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
10758          {
10759             macPdschCfg->bundlingInfo.StaticBundling.size = \
10760                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
10761          }
10762       }
10763    }
10764    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
10765    {
10766       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
10767    }
10768
10769 }
10770
10771 /*******************************************************************
10772  *
10773  * @brief Fills PdschServingCellCfg received by CU
10774  *
10775  * @details
10776  *
10777  *    Function : extractPdschServingCellCfg
10778  *
10779  *    Functionality: Fills PdschCfg received  by CU
10780  *
10781  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
10782  *             PdschServCellCfg *macUePdschSrvCellCfg
10783  * @return ROK/RFAILED
10784  *
10785  * ****************************************************************/
10786
10787 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
10788 {
10789    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
10790    {
10791       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
10792       {
10793          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
10794          {
10795             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
10796                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
10797          }
10798          else
10799          {
10800             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
10801             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
10802             {
10803                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
10804                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
10805             }
10806             else
10807             {
10808                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
10809                return RFAILED;
10810             }
10811          }
10812          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
10813          {
10814             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
10815                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
10816          }
10817          else
10818          {
10819             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
10820             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
10821             {
10822                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
10823                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
10824             }
10825             else
10826             {
10827                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
10828                return RFAILED;
10829             }
10830          }
10831       }
10832    }
10833    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
10834    {
10835       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
10836    }
10837    if(cuPdschSrvCellCfg->ext1)
10838    {
10839       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
10840       {
10841         if(macUePdschSrvCellCfg->maxMimoLayers)
10842         {
10843            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
10844         }
10845         else
10846         {
10847            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
10848            if(macUePdschSrvCellCfg->maxMimoLayers)
10849            {
10850               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
10851            }
10852            else
10853            {
10854               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
10855               return RFAILED;
10856            }
10857         }
10858       }
10859    }
10860    if(cuPdschSrvCellCfg->xOverhead)
10861    {
10862       if(macUePdschSrvCellCfg->xOverhead)
10863       {
10864          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
10865       }
10866       else
10867       {
10868          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
10869          if(macUePdschSrvCellCfg->xOverhead)
10870          {
10871             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
10872          }
10873          else
10874          {
10875             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
10876             return RFAILED;
10877          }
10878       }
10879    }
10880    return ROK;
10881 }
10882
10883 /*******************************************************************
10884  *
10885  * @brief Fills PuschCfg received by CU
10886  *
10887  * @details
10888  *
10889  *    Function : extractPuschCfg
10890  *
10891  *    Functionality: Fills PuschCfg received  by CU
10892  *
10893  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
10894  *             PuschCfg *macPuschCfg
10895  * @return void
10896  *
10897  * ****************************************************************/
10898
10899 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
10900 {
10901    uint8_t timeDomIdx = 0;
10902    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
10903    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
10904
10905    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
10906    {
10907       if(cuPuschCfg->choice.setup)
10908       {
10909          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
10910          {
10911              macPuschCfg->dataScramblingId = \
10912                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
10913          }
10914          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
10915          {
10916             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
10917             {
10918                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
10919                {
10920                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
10921                   if(dmrsUlCfg->dmrs_AdditionalPosition)
10922                   {
10923                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
10924                         *(dmrsUlCfg->dmrs_AdditionalPosition);
10925                   }
10926                   if(dmrsUlCfg->transformPrecodingDisabled)
10927                   {
10928                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
10929                      {
10930                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
10931                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
10932                      }
10933                   }
10934                }
10935             }
10936          }
10937          /*Res Alloc Type for UL */
10938          if(cuPuschCfg->choice.setup->resourceAllocation)
10939          {
10940             macPuschCfg->resourceAllocType = \
10941                cuPuschCfg->choice.setup->resourceAllocation;
10942          }
10943          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
10944          {
10945             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
10946             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
10947             {
10948                if(timeDomAllocList->choice.setup)
10949                {
10950                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
10951                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
10952                   {
10953                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
10954                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
10955                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
10956                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
10957                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
10958                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
10959                   }
10960                }
10961             }
10962          }
10963          if(cuPuschCfg->choice.setup->transformPrecoder)
10964             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
10965       }
10966    }
10967 }
10968
10969 /*******************************************************************
10970  *
10971  * @brief Function to fill pucch Power Control
10972  *
10973  * @details
10974  *
10975  *    Function : extractPucchPowerControl
10976  *
10977  *    Functionality: Function to fill pucch Power Control
10978  *
10979  * @params[in] PucchPowerControl *pwrCtrl,
10980  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
10981  * @return void
10982  *
10983  * ****************************************************************/
10984
10985 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
10986 {
10987    uint8_t arrIdx;
10988
10989    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
10990       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
10991    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
10992       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
10993    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
10994       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
10995    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
10996       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
10997    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
10998       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
10999    if(cuPwrCtrlCfg->p0_Set)
11000    {
11001       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
11002       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
11003       {
11004          pwrCtrl->p0Set[arrIdx].p0PucchId =\
11005             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
11006          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
11007             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
11008       }
11009    }
11010    if(cuPwrCtrlCfg->pathlossReferenceRSs)
11011    {
11012       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
11013       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
11014       {
11015          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
11016             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
11017       }
11018    }
11019 }
11020
11021  /*******************************************************************
11022  *
11023  * @brief Function to extractResrcSetToAddModList sent by CU
11024  *
11025  * @details
11026  *
11027  *    Function : extractResrcSetToAddModList
11028  *
11029  *    Functionality: Fucntion to extractResrcSetToAddModList
11030  *
11031  * @params[in] PucchResrcSetCfg pointer,
11032  *             struct PUCCH_Config__resourceSetToAddModList pointer
11033  * @return void
11034  *
11035  * ****************************************************************/
11036
11037 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
11038 {
11039    uint8_t arrIdx, rsrcListIdx;
11040
11041    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
11042    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
11043    {
11044       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
11045          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
11046       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
11047          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
11048       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
11049       {
11050          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
11051             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
11052       }
11053
11054       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
11055       {
11056          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
11057             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
11058       }
11059       else
11060       {
11061          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
11062       }
11063    }
11064 }/* End of extractResrcSetToAddModList */
11065
11066 /*******************************************************************
11067  *
11068  * @brief Fills extractResrcToAddModList sent by CU
11069  *
11070  * @details
11071  *
11072  *    Function : extractResrcToAddModList
11073  *
11074  *    Functionality: Fills extractResrcToAddModList
11075  *
11076  * @params[in] PucchResrcCfg pointer,
11077  *             struct PUCCH_Config__resourceToAddModList pointer
11078  * @return ROk/RFAILED
11079  *
11080  * ****************************************************************/
11081
11082 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
11083 {
11084    uint8_t arrIdx;
11085
11086    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
11087    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
11088    {
11089       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
11090         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
11091       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
11092         cuResrcList->list.array[arrIdx]->startingPRB;
11093       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
11094       {
11095          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
11096            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
11097       }
11098       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
11099       {
11100          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
11101            *cuResrcList->list.array[arrIdx]->secondHopPRB;
11102       }
11103       /* PUCCH RSRC FORMAT */
11104       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
11105       {
11106          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
11107          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
11108          {
11109             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
11110             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
11111             {
11112                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
11113                return RFAILED;
11114             }
11115             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
11116                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
11117             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
11118                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
11119             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
11120                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
11121          }
11122       }
11123       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
11124       {
11125          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
11126          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
11127          {
11128             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
11129             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
11130             {
11131                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
11132                return RFAILED;
11133             }
11134             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
11135                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
11136             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
11137                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
11138             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
11139                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
11140             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
11141                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
11142          }
11143       }
11144       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
11145       {
11146          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
11147          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
11148          {
11149             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
11150             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
11151             {
11152                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
11153                return RFAILED;
11154             }
11155             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
11156                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
11157             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
11158                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
11159             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
11160                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
11161          }
11162       }
11163       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
11164       {
11165          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
11166          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
11167          {
11168             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
11169             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
11170             {
11171                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
11172                return RFAILED;
11173             }
11174             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
11175                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
11176             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
11177                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
11178             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
11179                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
11180          }
11181       }
11182       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
11183       {
11184          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
11185          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
11186          {
11187             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
11188             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
11189             {
11190                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
11191                return RFAILED;
11192             }
11193             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
11194                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
11195             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
11196                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
11197             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
11198                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
11199             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
11200                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
11201          }
11202       }
11203    }
11204    return ROK;
11205
11206 }/* End of extractResrcToAddModList */
11207
11208 /*******************************************************************
11209  *
11210  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
11211  *
11212  * @details
11213  *
11214  *    Function : fillPucchSchedReqPeriodAndOffset
11215  *
11216  *    Functionality: To fillPucchSchedReqPeriodAndOffset
11217  *
11218  * @params[in] macPeriodicty,
11219  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
11220  * @return void
11221  *
11222  * ****************************************************************/
11223
11224 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
11225    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
11226 {
11227    macPeriodicty = cuPeriodicty->present;
11228    switch(macPeriodicty)
11229    {
11230       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
11231          {
11232             macOffset     = cuPeriodicty->choice.sym2;
11233             break;
11234          }
11235       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
11236          {
11237             macOffset     = cuPeriodicty->choice.sym6or7;
11238             break;
11239          }
11240       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
11241          {
11242             macOffset     = cuPeriodicty->choice.sl1;
11243             break;
11244          }
11245       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
11246          {
11247             macOffset = cuPeriodicty->choice.sl2;
11248             break;
11249          }
11250       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
11251          {
11252             macOffset = cuPeriodicty->choice.sl4;
11253             break;
11254          }
11255       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
11256          {
11257             macOffset = cuPeriodicty->choice.sl5;
11258             break;
11259          }
11260       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
11261          {
11262             macOffset = cuPeriodicty->choice.sl8;
11263             break;
11264          }
11265       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
11266          {
11267             macOffset = cuPeriodicty->choice.sl10;
11268             break;
11269          }
11270       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
11271          {
11272             macOffset = cuPeriodicty->choice.sl16;
11273             break;
11274          }
11275       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
11276          {
11277             macOffset = cuPeriodicty->choice.sl20;
11278             break;
11279          }
11280       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
11281          {
11282             macOffset = cuPeriodicty->choice.sl40;
11283             break;
11284          }
11285       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
11286          {
11287             macOffset = cuPeriodicty->choice.sl80;
11288             break;
11289          }
11290       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
11291          {
11292             macOffset = cuPeriodicty->choice.sl160;
11293             break;
11294          }
11295       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
11296          {
11297             macOffset = cuPeriodicty->choice.sl320;
11298             break;
11299          }
11300       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
11301          {
11302             macOffset = cuPeriodicty->choice.sl640;
11303             break;
11304          }
11305       default :
11306          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
11307    }
11308 }
11309
11310 /*******************************************************************
11311  *
11312  * @brief Function to extractPucchFormatCfg sent by CU
11313  *
11314  * @details
11315  *
11316  *    Function : extractPucchFormatCfg
11317  *
11318  *    Functionality: Function to extractPucchFormatCfg
11319  *
11320  * @params[in] PucchFormatCfg pointer,
11321  *             PUCCH_FormatConfig_t pointer
11322  * @return void
11323  *
11324  * ****************************************************************/
11325
11326 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
11327  {
11328     if(cuFormatCfg->interslotFrequencyHopping)
11329        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
11330     if(cuFormatCfg->additionalDMRS)
11331        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
11332     if(cuFormatCfg->maxCodeRate)
11333        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
11334     if(cuFormatCfg->nrofSlots)
11335        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
11336     if(cuFormatCfg->pi2BPSK)
11337        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
11338     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
11339        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
11340  }/* End of extractPucchFormatCfg */
11341
11342 /*******************************************************************
11343  *
11344  * @brief Function to extractSchedReqCfgToAddMod sent by CU
11345  *
11346  * @details
11347  *
11348  *    Function : extractSchedReqCfgToAddMod
11349  *
11350  *    Functionality: Function to extractSchedReqCfgToAddMod
11351  *
11352  * @params[in] PucchSchedReqCfg pointer,
11353  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
11354  * @return void
11355  *
11356  * ****************************************************************/
11357
11358 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
11359 {
11360    uint8_t arrIdx;
11361
11362    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
11363    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
11364    {
11365       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
11366          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
11367       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
11368          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
11369       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
11370       {
11371          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
11372             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
11373       }
11374       if(cuSchedReqList->list.array[arrIdx]->resource)
11375       {
11376          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
11377             *cuSchedReqList->list.array[arrIdx]->resource;
11378       }
11379    }
11380
11381 }/* End of extractSchedReqCfgToAddMod */
11382
11383  /*******************************************************************
11384  *
11385  * @brief Fills PucchCfg received by CU
11386  *
11387  * @details
11388  *
11389  *    Function : extractPucchCfg
11390  *
11391  *    Functionality: Fills PucchCfg received  by CU
11392  *
11393  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
11394  *                is send by CU, which we have stored in F1UeContextSetupDb,
11395  *             PucchCfg *macPucchCfg = Used to Store the information which
11396  *                needs to send in other layer, as well as this can be the variable
11397  *                which stores the information in DuCb,
11398  *             PucchCfg *storedPucchCfg = Null in case of sending the
11399  *                information to other layer else it will have Pucch Cfg which
11400  *                we have stored in copyOfmacUeCfg.
11401  * @return ROK/RFAILED
11402  *
11403  * ****************************************************************/
11404
11405 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
11406 PucchCfg *storedPucchCfg)
11407 {
11408    uint8_t arrIdx;
11409
11410    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
11411    {
11412       if(cuPucchCfg->choice.setup)
11413       {
11414          /* Resource Set Cfg */
11415          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
11416          {
11417             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
11418             if(macPucchCfg->resrcSet == NULLP)
11419             {
11420                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
11421                return RFAILED;
11422             }
11423             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
11424             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
11425          }
11426
11427          /* Resource Cfg */
11428          if(cuPucchCfg->choice.setup->resourceToAddModList)
11429          {
11430             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
11431             if(macPucchCfg->resrc == NULLP)
11432             {
11433                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
11434                return RFAILED;
11435             }
11436             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
11437             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
11438          }
11439
11440          /* Format 1 Cfg */
11441          if(cuPucchCfg->choice.setup->format1)
11442          {
11443             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
11444             if(macPucchCfg->format1 == NULLP)
11445             {
11446                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
11447                return RFAILED;
11448             }
11449             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
11450             extractPucchFormatCfg(macPucchCfg->format1,\
11451                cuPucchCfg->choice.setup->format1->choice.setup);
11452          }
11453
11454          /* Format 2 Cfg */
11455          if(cuPucchCfg->choice.setup->format2)
11456          {
11457             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
11458             if(macPucchCfg->format2 == NULLP)
11459             {
11460                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
11461                return RFAILED;
11462             }
11463             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
11464             extractPucchFormatCfg(macPucchCfg->format2,\
11465                cuPucchCfg->choice.setup->format2->choice.setup);
11466          }
11467
11468          /* Format 3 Cfg */
11469          if(cuPucchCfg->choice.setup->format3)
11470          {
11471             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
11472             if(macPucchCfg->format3 == NULLP)
11473             {
11474                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
11475                return RFAILED;
11476             }
11477             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
11478             extractPucchFormatCfg(macPucchCfg->format3,\
11479                cuPucchCfg->choice.setup->format3->choice.setup);
11480          }
11481
11482          /* Format 4 Cfg */
11483          if(cuPucchCfg->choice.setup->format4)
11484          {
11485             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
11486             if(macPucchCfg->format4 == NULLP)
11487             {
11488                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
11489                return RFAILED;
11490             }
11491             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
11492             extractPucchFormatCfg(macPucchCfg->format4,\
11493                cuPucchCfg->choice.setup->format4->choice.setup);
11494          }
11495
11496          /* Sched Req List */
11497          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
11498          {
11499             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
11500             if(macPucchCfg->schedReq == NULLP)
11501             {
11502                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
11503                return RFAILED;
11504             }
11505             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
11506             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
11507             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
11508          }
11509
11510          /*TODO: Add support for  Spatial Info */
11511
11512          /* MultiCsiCfg */
11513          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
11514          {
11515             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
11516             if(macPucchCfg->multiCsiCfg == NULLP)
11517             {
11518                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
11519                return RFAILED;
11520             }
11521             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
11522             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
11523             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
11524             {
11525                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
11526                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
11527             }
11528          }
11529
11530          /* Dl_DataToUL_ACK */
11531          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
11532     {
11533        if(storedPucchCfg)
11534        {
11535           if(storedPucchCfg->dlDataToUlAck)
11536           {
11537              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
11538           }
11539           else
11540           {
11541             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11542           }
11543        }
11544        else
11545        {
11546           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11547        }
11548        if(macPucchCfg->dlDataToUlAck == NULLP)
11549        {
11550           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
11551           return RFAILED;
11552        }
11553        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
11554        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
11555        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
11556        {
11557           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
11558           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
11559        }
11560          }
11561
11562          /* Power Control */
11563          if(cuPucchCfg->choice.setup->pucch_PowerControl)
11564          {
11565             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
11566             if(macPucchCfg->powerControl == NULLP)
11567             {
11568                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
11569                return RFAILED;
11570             }
11571             extractPucchPowerControl(macPucchCfg->powerControl,\
11572                cuPucchCfg->choice.setup->pucch_PowerControl);
11573          }
11574       }
11575    }
11576    return ROK;
11577 }
11578
11579 /*******************************************************************
11580  *
11581  * @brief Fills ServingCellReconfig received by CU
11582  *
11583  * @details
11584  *
11585  *    Function : extractSpCellDedicatedCfg
11586  *
11587  *    Functionality: Fills ServingCellReconfig received  by CU
11588  *
11589  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
11590  *                  CU, which we have stored in F1UeContextSetupDb,
11591  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
11592  *                  which  needs to send in other layer, as well as this can be the
11593  *                  variable which stores the information in DuCb,
11594  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
11595  *                  information to other layer else it will have ServCellCfgInfo which
11596  *                  we have stored in copyOfmacUeCfg.
11597  * @return ROK/RFAILD
11598  *
11599  * ****************************************************************/
11600 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
11601 ServCellCfgInfo *storedSrvCellCfg)
11602 {
11603    uint8_t ret = ROK;
11604    BWP_DownlinkDedicated_t *dlBwp = NULLP;
11605    BWP_UplinkDedicated_t   *ulBwp = NULLP;
11606
11607    if(cuSrvCellCfg->initialDownlinkBWP)
11608    {
11609       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
11610       if(dlBwp->pdcch_Config)
11611       {
11612          if(dlBwp->pdcch_Config->choice.setup)
11613          {
11614             macSrvCellCfg->initDlBwp.pdcchPresent = true;
11615             if(storedSrvCellCfg)
11616             {
11617                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
11618                {
11619                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11620                }
11621                else
11622                {
11623                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11624                }
11625             }
11626             else
11627             {
11628                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11629             }
11630          }
11631       }
11632       if(dlBwp->pdsch_Config)
11633       {
11634          if(dlBwp->pdsch_Config->choice.setup)
11635          {
11636             macSrvCellCfg->initDlBwp.pdschPresent = true;
11637
11638             if(storedSrvCellCfg)
11639             {
11640                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
11641                {
11642                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11643                }
11644                else
11645                {
11646                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
11647                         &storedSrvCellCfg->initDlBwp.pdschCfg);
11648                }
11649             }
11650             else
11651             {
11652                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11653             }
11654          }
11655       }
11656    }
11657    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
11658       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
11659    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
11660       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
11661    if(cuSrvCellCfg->bwp_InactivityTimer)
11662    {
11663       if(macSrvCellCfg->bwpInactivityTmr)
11664       {
11665          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11666       }
11667       else
11668       {
11669          macSrvCellCfg->bwpInactivityTmr = NULLP;
11670          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
11671          if(macSrvCellCfg->bwpInactivityTmr)
11672          {
11673             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11674          }
11675          else
11676          {
11677             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
11678             return RFAILED;
11679          }
11680       }
11681    }
11682    if(cuSrvCellCfg->pdsch_ServingCellConfig)
11683    {
11684       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
11685       {
11686          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
11687          if(ret == RFAILED)
11688          {
11689             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
11690             return RFAILED;
11691          }
11692       }
11693    }
11694    if(cuSrvCellCfg->uplinkConfig)
11695    {
11696       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
11697       {
11698          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
11699          if(ulBwp->pusch_Config)
11700          {
11701             macSrvCellCfg->initUlBwp.puschPresent = true;
11702             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
11703          }
11704          if(ulBwp->pucch_Config)
11705          {
11706             macSrvCellCfg->initUlBwp.pucchPresent = true;
11707             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
11708             if(storedSrvCellCfg)
11709             {
11710                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
11711                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11712                else
11713                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
11714                   &storedSrvCellCfg->initUlBwp.pucchCfg);
11715             }
11716             else
11717             {
11718                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11719             }
11720          }
11721       }
11722       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
11723          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
11724    }
11725    return ret;
11726 }
11727 /*******************************************************************
11728  *
11729  * @brief Fills Reconfig Cell group Info received by CU
11730  *
11731  * @details
11732  *
11733  *    Function : extractUeReCfgCellInfo
11734  *
11735  *    Functionality: Fills Reconfig Cell group Info received by CU
11736  *
11737  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
11738  *                       is send by CU, which we have stored in F1UeContextSetupDb
11739  *             MacUeCfg *MacUeCfg = Used to Store the information,
11740  *                      which needs to send in other layer, as well as this can be
11741  *                      the variable which stores the information in DuCb,
11742  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
11743  *                      information to other layer else it will have copyOfmacUeCfg
11744  *                      which we have stored in F1UeContextSetupDb.
11745  *
11746  * @return ROK/RFAILED
11747  *
11748  * ****************************************************************/
11749 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
11750 {
11751    uint8_t ret = ROK;
11752    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
11753    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
11754    SpCellConfig_t            *spcellCfg = NULLP;
11755    ServingCellConfig_t       *servCellCfg = NULLP;
11756
11757    if(cellGrp)
11758    {
11759       /* Fill MacCell Group Reconfig  */
11760       if(cellGrp->mac_CellGroupConfig)
11761       {
11762          macUeCfg->macCellGrpCfgPres = true;
11763          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
11764          if(macCellGroup->schedulingRequestConfig)
11765          {
11766             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
11767          }
11768          if(macCellGroup->tag_Config)
11769          {
11770             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
11771          }
11772          if(macCellGroup->bsr_Config)
11773          {
11774             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
11775             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
11776             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
11777             {
11778                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
11779                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
11780             }
11781          }
11782          if(macCellGroup->phr_Config)
11783          {
11784             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
11785             {
11786                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
11787                if(macCellGroup->phr_Config->choice.setup)
11788                {
11789                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
11790                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
11791                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
11792                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
11793                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
11794                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
11795                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
11796                   macCellGroup->phr_Config->choice.setup->multiplePHR;
11797                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
11798                   macCellGroup->phr_Config->choice.setup->dummy;
11799                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
11800                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
11801                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
11802                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
11803                }
11804             }
11805          }
11806       }
11807       /* Fill Physical Cell Group Reconfig */
11808       if(cellGrp->physicalCellGroupConfig)
11809       {
11810          macUeCfg->phyCellGrpCfgPres = true;
11811          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
11812          if(phyCellGrpCfg->p_NR_FR1)
11813          {
11814             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
11815                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
11816          }
11817          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
11818       }
11819       /* Fill SpCell Reconfig */
11820       if(cellGrp->spCellConfig)
11821       {
11822          macUeCfg->spCellCfgPres = true;
11823          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
11824          if(spcellCfg->servCellIndex)
11825          {
11826             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
11827          }
11828          /* Fill Serving cell Reconfig info */
11829          if(cellGrp->spCellConfig->spCellConfigDedicated)
11830          {
11831             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
11832             if(storedMacUeCfg)
11833             {
11834                if(!storedMacUeCfg->spCellCfgPres)
11835                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
11836                else
11837                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
11838                         &storedMacUeCfg->spCellCfg.servCellCfg);
11839             }
11840             else
11841             {
11842                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
11843             }
11844             if(ret == RFAILED)
11845             {
11846                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
11847             }
11848          }
11849       }
11850    }
11851    return ret;
11852 }
11853 /*******************************************************************
11854 *
11855 * @brief free the memory allocated by decoder
11856 *
11857 * @details
11858 *
11859 *    Function : freeAperDecodeNrcgi
11860 *
11861 *    Functionality: Free Nrcgi values
11862 *
11863 * @params[in] NRCGI_t *nrcgi
11864 * @return void
11865 *
11866 * ****************************************************************/
11867
11868
11869 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
11870 {
11871     if(nrcgi->pLMN_Identity.buf != NULLP)
11872     {
11873        free(nrcgi->pLMN_Identity.buf);
11874     }
11875     if(nrcgi->nRCellIdentity.buf != NULLP)
11876     {
11877        free(nrcgi->nRCellIdentity.buf);
11878     }
11879 }
11880 /*******************************************************************
11881 *
11882 * @brief free the memory allocated by decoder
11883 *
11884 * @details
11885 *
11886 *    Function : freeAperDecodeCuToDuInfo
11887 *
11888 *    Functionality:  Free Cu To Du Information
11889 *
11890 * @params[in] CUtoDURRCInformation_t *rrcMsg
11891 * @return void
11892 *
11893 * ****************************************************************/
11894
11895
11896 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
11897 {
11898    uint8_t ieIdx =0;
11899    uint8_t arrIdx =0;
11900
11901    if(rrcMsg->uE_CapabilityRAT_ContainerList)
11902    {
11903       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
11904          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
11905       free(rrcMsg->uE_CapabilityRAT_ContainerList);
11906    }
11907
11908    if(rrcMsg->iE_Extensions)
11909    {
11910       if(rrcMsg->iE_Extensions->list.array)
11911       {
11912          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
11913          {
11914             if(rrcMsg->iE_Extensions->list.array[ieIdx])
11915             {
11916                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
11917                {
11918                   case ProtocolIE_ID_id_CellGroupConfig:
11919                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
11920                      {
11921                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
11922                      }
11923                      break;
11924                   default:
11925                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
11926                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
11927                      break;
11928                }
11929             }
11930          }
11931          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
11932          {
11933             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
11934          }
11935          free(rrcMsg->iE_Extensions->list.array);
11936
11937       }
11938
11939       free(rrcMsg->iE_Extensions);
11940    }
11941 }
11942 /*******************************************************************
11943 *
11944 * @brief free the memory allocated by decoder
11945 *
11946 * @details
11947 *
11948 *    Function : freeAperDecodeSplCellList
11949 *
11950 *    Functionality: Free Spl Cell List
11951                     where memory allocated by aper_decoder
11952 *
11953 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
11954 * @return void
11955 *
11956 * ****************************************************************/
11957
11958
11959 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
11960 {
11961     uint8_t  cellIdx =0;
11962
11963     if(spCellLst->list.array != NULLP)
11964     {
11965        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
11966        {
11967           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
11968           {
11969              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
11970           }
11971           if(spCellLst->list.array[cellIdx]!=NULLP)
11972           {
11973              free(spCellLst->list.array[cellIdx]);
11974           }
11975        }
11976        free(spCellLst->list.array);
11977     }
11978 }
11979 /*******************************************************************
11980 *
11981 * @brief free the memory allocated by decoder
11982 *
11983 * @details
11984 *
11985 *    Function : freeAperDecodeSRBSetup
11986 *
11987 *    Functionality: added free part for the memory allocated by aper_decoder
11988 *
11989 * @params[in] SRBs_ToBeSetup_List_t *srbSet
11990 * @return void
11991 *
11992 ****************************************************************/
11993
11994
11995 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
11996 {
11997     uint8_t srbIdx =0;
11998     if(srbSet->list.array != NULLP)
11999     {
12000        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
12001        {
12002           if(srbSet->list.array[srbIdx]!=NULLP)
12003           {
12004              free(srbSet->list.array[srbIdx]);
12005           }
12006        }
12007        free(srbSet->list.array);
12008     }
12009 }
12010
12011 /*******************************************************************
12012 *
12013 * @brief free the memory allocated by decoder
12014 *
12015 * @details
12016 *
12017 *    Function : freeAperDecodeULTnlInfo
12018 *
12019 *    Functionality: added free part for the memory allocated by aper_decoder
12020 *
12021 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12022 * @return void
12023 *
12024 * ****************************************************************/
12025
12026
12027 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12028 {
12029    uint8_t ulIdx=0;
12030    if(ulInfo->list.array != NULLP)
12031    {
12032       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
12033       {
12034          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
12035          {
12036             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
12037             {
12038                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12039                      transportLayerAddress.buf != NULLP)
12040                {
12041                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
12042                         !=NULLP)
12043                   {
12044                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
12045                   }
12046                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12047                         transportLayerAddress.buf);
12048                }
12049                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
12050             }
12051          }
12052          if(ulInfo->list.array[ulIdx]!=NULLP)
12053          {
12054             free(ulInfo->list.array[ulIdx]);
12055          }
12056       }
12057       free(ulInfo->list.array);
12058    }
12059 }
12060 /*******************************************************************
12061 *
12062 * @brief free the memory allocated by decoder
12063 *
12064 * @details
12065 *
12066 *    Function : freeAperDecodeDRBSetup
12067 *
12068 *    Functionality: free DRBSetup which is allocated by decoder
12069 *
12070 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
12071 * @return void
12072 *
12073 * ****************************************************************/
12074
12075 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
12076 {
12077    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
12078    uint8_t  flowIdx =0;
12079    uint8_t  drbIdx =0;
12080
12081    if(drbSet->list.array != NULLP)
12082    {
12083       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
12084       {
12085          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
12086          {
12087             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
12088             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
12089             {
12090                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12091                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
12092                {
12093                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12094                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12095                   {
12096                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12097                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12098                      {
12099
12100                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
12101                         {
12102
12103                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
12104                            {
12105
12106                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
12107                                     buf!=NULLP)
12108                               {
12109
12110                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
12111                                        flows_Mapped_To_DRB_List.list.array != NULLP)
12112                                  {
12113
12114                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12115                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
12116                                     {
12117
12118                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12119                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12120                                        {
12121                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12122                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12123                                                 qoSFlowLevelQoSParameters.\
12124                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
12125                                           {
12126                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12127                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12128                                                    qoSFlowLevelQoSParameters.\
12129                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12130                                              {
12131
12132                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12133                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12134                                                       qoSFlowLevelQoSParameters.\
12135                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12136                                                 {
12137
12138
12139                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12140                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12141                                                          qoSFlowLevelQoSParameters.\
12142                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12143                                                 }
12144
12145                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12146                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12147                                                       qoSFlowLevelQoSParameters.\
12148                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12149                                              }
12150
12151                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12152
12153                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12154                                                    qoSFlowLevelQoSParameters.\
12155                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
12156                                           }
12157                                        }
12158                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12159                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12160                                        {
12161
12162                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12163                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
12164                                        }
12165                                     }
12166
12167                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12168                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
12169                                  }
12170
12171                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12172                                        DRB_Information.sNSSAI.sD->buf);
12173                               }
12174
12175                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
12176                            }
12177
12178                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
12179
12180                         }
12181
12182                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12183
12184                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12185                      }
12186
12187                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12188                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12189                   }
12190
12191                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12192                         qoS_Characteristics.choice.non_Dynamic_5QI);
12193                }
12194                free(drbSetItem->qoSInformation.choice.choice_extension);
12195             }
12196             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
12197             if(drbSetItem->uLConfiguration)
12198             {
12199                free(drbSetItem->uLConfiguration);
12200             }
12201          }
12202          if(drbSet->list.array[drbIdx]!=NULLP)
12203          {
12204             free(drbSet->list.array[drbIdx]);
12205          }
12206       }
12207       free(drbSet->list.array);
12208    }
12209 }
12210
12211
12212 /*******************************************************************
12213  *
12214  * @brief builds Mac Cell Cfg
12215  *
12216  * @details
12217  *
12218  *    Function : procUeReCfgCellInfo
12219  *
12220  *    Functionality: builds Mac Cell Cfg
12221  *
12222  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
12223  *                       needs to send in other layer, as well as this can be
12224  *                       the variable which stores the information in DuCb.
12225  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
12226  *                       information to other layer else it will have copyOfmacUeCfg
12227  *                       which we have stored in F1UeContextSetupDb
12228  *             void *cellInfo = CellGroupConfigRrc_t information which is send
12229  *                        by CU, which we have stored in F1UeContextSetupDb
12230  *
12231  * @return void
12232  *
12233  * ****************************************************************/
12234 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, MacUeCfg *storedMacUeCfg, void *cellInfo)
12235 {
12236    uint8_t ret = ROK;
12237    CellGroupConfigRrc_t *cellGrp = NULLP;
12238
12239    if(cellInfo)
12240    {
12241       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
12242       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
12243       if(ret == RFAILED)
12244          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
12245    }
12246    if(ret == RFAILED)
12247    {
12248       freeUeReCfgCellGrpInfo(macUeCfgToSend);
12249    }
12250    return ret;
12251 }
12252
12253 /*******************************************************************
12254  *
12255  * @brief Filling modulation info in mac ue cfg
12256  *
12257  * @details
12258  *
12259  *    Function : duFillModulationDetails
12260  *
12261  *    Functionality: Filling modulation info in mac ue cfg
12262  *
12263  * @params[in] MAC UE Config to be updated
12264  *             Current UE configuration
12265  *             UE NR capability from CU
12266  * @return ROK     - success
12267  *         RFAILED - failure
12268  *
12269  * ****************************************************************/
12270 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
12271 {
12272    UE_NR_Capability_t *ueNrCap=NULLP;
12273
12274    if(!ueCap && oldUeCfg)
12275    {
12276       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12277       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12278    }
12279    else
12280    {
12281       ueNrCap = (UE_NR_Capability_t *)ueCap;
12282
12283       /* Filling DL modulation info */
12284       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
12285          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
12286          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
12287       {
12288          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
12289          {
12290             case ModulationOrder_qpsk:
12291                {
12292                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
12293                   break;
12294                }
12295             case ModulationOrder_qam16:
12296                {
12297                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
12298                   break;
12299                }
12300             case ModulationOrder_qam64:
12301                {
12302                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
12303                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
12304                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
12305                   break;
12306                }
12307             case ModulationOrder_qam256:
12308                {
12309                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
12310                   break;
12311                }
12312             default:
12313                {
12314                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
12315                   if(oldUeCfg)
12316                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12317                   break;
12318                }
12319          }
12320       }
12321       else
12322       {
12323          if(oldUeCfg)
12324             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12325       }
12326
12327       /* Filling UL modulation info */
12328       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
12329          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
12330          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
12331       {
12332          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
12333          {
12334             case ModulationOrder_qpsk:
12335                {
12336                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
12337                   break;
12338                }
12339             case ModulationOrder_qam16:
12340                {
12341                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
12342                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
12343                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
12344                   break;
12345                }
12346             case ModulationOrder_qam64:
12347                {
12348                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
12349                   break;
12350                }
12351             case ModulationOrder_qam256:
12352                {
12353                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
12354                   break;
12355                }
12356             default:
12357                {
12358                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
12359                   if(oldUeCfg)
12360                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12361                   break;
12362                }
12363          }
12364       }
12365       else
12366       {
12367          if(oldUeCfg)
12368             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12369       }
12370    }
12371 }
12372
12373 /*******************************************************************
12374  *
12375  * @brief Function to extract info from CU to DU RRC container extension
12376  *
12377  * @details
12378  *
12379  *    Function : extractCuToDuRrcInfoExt
12380  *
12381  *    Functionality: Function to extract info from CU to DU RRC container
12382  *    extension
12383  *
12384  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
12385  *
12386  * @return ROK
12387  *         RFAILED
12388  *
12389  * ****************************************************************/
12390 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
12391 {
12392    uint8_t ieIdx =0;
12393    uint16_t recvBufLen =0;
12394    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
12395    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
12396    asn_dec_rval_t rval; /* Decoder return value */
12397    memset(&rval, 0, sizeof(asn_dec_rval_t));
12398
12399    if(protocolIeExtn)
12400    {
12401       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
12402       {
12403          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
12404          switch(extIeInfo->id)
12405          {
12406             case ProtocolIE_ID_id_CellGroupConfig:
12407                {
12408                   /* decoding the CellGroup Buf received */
12409                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
12410                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
12411                   if(cellGrpCfg)
12412                   {
12413                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
12414                      rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
12415                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
12416                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12417                      {
12418                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
12419                         return RFAILED;
12420                      }
12421                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
12422
12423                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
12424                         return NULLP;
12425                      ueCfgDb->cellGrpCfg = cellGrpCfg;
12426                   }
12427                   break;
12428                }
12429
12430             case ProtocolIE_ID_id_HandoverPreparationInformation:
12431                {
12432                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
12433                   break;
12434                }
12435
12436             default:
12437                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
12438                break;
12439          }
12440       }
12441    }
12442    return ROK;
12443 }
12444
12445 /*******************************************************************
12446  *
12447  * @brief Fills Srb List received by CU
12448  *
12449  * @details
12450  *
12451  *    Function : procSrbListToSetup
12452  *
12453  *    Functionality: Fills Srb List received  by CU
12454  *
12455  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
12456  *             LcCfg pointer
12457  *             RlcBearerCfg pointer
12458  * @return void
12459  *
12460  * ****************************************************************/
12461 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
12462 {
12463
12464    /* Filling RLC INFO */
12465    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
12466
12467    /* Filling MAC INFO */
12468    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
12469    {
12470       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
12471       return RFAILED;
12472    }
12473
12474    return ROK;
12475 }
12476
12477
12478
12479 /*******************************************************************
12480  *
12481  * @brief extract Srb List received by CU
12482  *
12483  * @details
12484  *
12485  *    Function : extractSrbListToSetup
12486  *
12487  *    Functionality: extract Srb List received by CU
12488  *                   for both MAC and RLC
12489  *
12490  * @params[in] SRBs_ToBeSetup_Item_t pointer
12491  *             DuUeCfg pointer
12492  * @return ROK/RFAIED
12493  *
12494  * ****************************************************************/
12495
12496 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
12497 {
12498    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
12499    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
12500    LcCfg *macLcCtxt = NULLP;
12501    RlcBearerCfg *rlcLcCtxt = NULLP;
12502
12503    if(srbCfg)
12504    {
12505       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
12506       {
12507          macLcCtxt = NULL;
12508          rlcLcCtxt = NULL;
12509
12510          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
12511          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
12512          {
12513             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
12514             ret = RFAILED;
12515             break;
12516          }
12517          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
12518          {
12519             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
12520             ret = RFAILED;
12521             break;
12522          }
12523
12524          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
12525          {
12526             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_SRB)
12527             {
12528                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
12529                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
12530                break;
12531             }
12532          }
12533          if(!macLcCtxt)
12534          {
12535             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
12536             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
12537             ueCfgDb->numMacLcs++;
12538          }
12539          if(!rlcLcCtxt)
12540          {
12541             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
12542             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
12543             ueCfgDb->numRlcLcs++;
12544          }
12545
12546          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
12547
12548          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
12549                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
12550          if(ret == RFAILED)
12551          {
12552             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
12553             break;
12554          }
12555       }
12556    }
12557    else
12558       ret = RFAILED;
12559
12560    return ret;
12561 }
12562
12563 /*******************************************************************
12564  *
12565  * @brief Fills Drb List received by CU
12566  *
12567  * @details
12568  *
12569  *    Function : procDrbListToSetupMod
12570  *
12571  *    Functionality: Fills Drb List received by CU
12572  *                   for both MAC and RLC
12573  *
12574  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
12575  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
12576  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
12577  * @return void
12578  *
12579  * ****************************************************************/
12580
12581 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
12582 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
12583 {
12584    uint8_t cfgIdx = 0;
12585    RlcMode rlcModeInfo;
12586
12587    if(drbItem != NULLP)
12588    {
12589       /* Filling RLC INFO */
12590       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
12591       qoSInformation);
12592
12593       /* Filling MAC INFO */
12594       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
12595       {
12596          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
12597          return RFAILED;
12598       }
12599    }
12600    else if(drbSetupModItem != NULLP)
12601    {
12602       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
12603       &drbSetupModItem->qoSInformation);
12604
12605       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
12606       {
12607          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
12608          return RFAILED;
12609       }
12610    }
12611    else if(drbModItem != NULLP)
12612    {
12613       /* Drb to Mod IEs doesnot have rlcMode to be modified
12614        * in ASN. Hence no change in RLC configurations */
12615       if(storedRlcUeCfg != NULLP)
12616       {
12617          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
12618          {
12619             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
12620             {
12621                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
12622                break;
12623             }
12624          }
12625       }
12626
12627       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
12628       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
12629       {
12630          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
12631          return RFAILED;
12632       }
12633    }
12634    return ROK;
12635 }
12636
12637 /*******************************************************************
12638  *
12639  * @brief extract Drb List received by CU
12640  *
12641  * @details
12642  *
12643  *    Function : extractDrbListToSetupMod
12644  *
12645  *    Functionality: extract Drb List received by CU
12646  *                   for both MAC and RLC
12647  *
12648  * @params[in] DRBs_ToBeSetup_Item_t pointer
12649  *             DuUeCfg pointer
12650  * @return ROK/RFAIED
12651  *
12652  * ****************************************************************/
12653
12654 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
12655  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
12656 {
12657    uint8_t ret = ROK;
12658    uint8_t drbIdx = 0, rlcLcIdx = 0;
12659    uint8_t drbId = 0, lcId = 0;
12660    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
12661    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
12662    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
12663    LcCfg *macLcCtxt = NULLP;
12664    RlcBearerCfg *rlcLcCtxt = NULLP;
12665
12666    ret = ROK;
12667    if(drbCount > 0)
12668    {
12669       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
12670       {
12671          macLcCtxt = NULL;
12672          rlcLcCtxt = NULL;
12673
12674          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
12675          {
12676             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
12677             ret = RFAILED;
12678             break;
12679          }
12680          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
12681          {
12682             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
12683             ret = RFAILED;
12684             break;
12685          }
12686
12687          if(drbModCfg != NULLP)
12688          {
12689             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
12690             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
12691          }
12692          else if(drbCfg != NULLP)
12693             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
12694          else if(drbSetupModCfg != NULL)
12695          {
12696             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
12697             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
12698          }
12699
12700          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
12701          {
12702             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
12703             {
12704                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
12705                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
12706                break;
12707             }
12708          }
12709          if(!macLcCtxt)
12710          {
12711             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
12712             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
12713             ueCfgDb->numMacLcs++;
12714          }
12715          if(!rlcLcCtxt)
12716          {
12717             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
12718             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
12719             ueCfgDb->numRlcLcs++;
12720          }
12721
12722          if(drbModCfg != NULLP)
12723          {
12724             lcId = fetchLcId(drbId);
12725             if(lcId < MIN_DRB_LCID)
12726             {
12727                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
12728                break;
12729             }
12730             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
12731             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
12732             if(ret == RFAILED)
12733             {
12734                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
12735                break;
12736             }
12737          }
12738          else
12739          {
12740             lcId = getDrbLcId(drbBitMap);
12741             if(lcId == RFAILED)
12742             {
12743                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
12744                ret = RFAILED;
12745                break;
12746             }
12747             if(drbCfg != NULL)
12748             {
12749                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
12750                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
12751                if(ret == RFAILED)
12752                {
12753                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
12754                   break;
12755                }
12756             }
12757             else if(drbSetupModCfg != NULL)
12758             {
12759                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
12760                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
12761                if(ret == RFAILED)
12762                {
12763                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
12764                   break;
12765                }
12766                ueCfgDb->numDrbSetupMod++;
12767             }
12768          }
12769          ueCfgDb->numDrb++;
12770
12771          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
12772                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
12773          if(ret == RFAILED)
12774          {
12775             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
12776             break;
12777          }
12778       }
12779    }
12780    else
12781       ret = RFAILED;
12782
12783    return ret;
12784 }
12785
12786 /*******************************************************************
12787  *
12788  * @brief Function to extract Dl RRC Msg received from CU
12789  *
12790  * @details
12791  *
12792  *    Function : extractDlRrcMsg
12793  *
12794  *    Functionality: Function to extract Dl RRC Msg received from CU
12795  *
12796  * @params[in] F1AP message
12797  * @return ROK     - success
12798  *         RFAILED - failure
12799  *
12800  * ****************************************************************/
12801
12802 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
12803    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
12804 {
12805    uint8_t ret = ROK;
12806    dlRrcMsg->rrcMsgSize = rrcContainer->size;
12807    if(dlRrcMsg->rrcMsgSize > 0)
12808    {
12809       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
12810       if(!dlRrcMsg->rrcMsgPdu)
12811       {
12812          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
12813          ret = RFAILED;
12814       }
12815       else
12816       {
12817          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
12818          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
12819          dlRrcMsg->srbId = SRB1_LCID;
12820          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
12821       }
12822    }
12823    return ret;
12824 }
12825
12826 /*******************************************************************
12827  *
12828  * @brief Extract UE capability info
12829  *
12830  * @details
12831  *
12832  *    Function : extractUeCapability
12833  *
12834  *    Functionality: Extract UE capability info and stores in ue Cb
12835  *
12836  * @params[in] Octet string of UE capability RAT container list
12837  * @return ROK     - success
12838  *         RFAILED - failure
12839  *
12840  * ****************************************************************/
12841 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
12842 {
12843    uint8_t  idx;
12844    uint16_t recvBufLen;
12845    asn_dec_rval_t rval;
12846    UE_NR_Capability_t  *ueNrCap = NULLP;
12847    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
12848
12849    /* Decoding UE Capability RAT Container List */
12850    recvBufLen = ueCapablityListBuf->size;
12851    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
12852    if(!ueCapRatContList)
12853    {
12854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
12855       return NULLP;
12856    }
12857    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
12858    memset(&rval, 0, sizeof(asn_dec_rval_t));
12859    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
12860           ueCapablityListBuf->buf, recvBufLen, 0, 0);
12861    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12862    {
12863       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
12864       return NULLP;
12865    }
12866    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
12867
12868    /* Free encoded buffer after decoding */
12869
12870    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
12871    {
12872       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
12873       {
12874          /* Decoding UE NR Capability */
12875           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
12876           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
12877           if(!ueNrCap)
12878           {
12879              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
12880              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
12881              return NULLP;
12882           }
12883           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
12884           memset(&rval, 0, sizeof(asn_dec_rval_t));
12885           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
12886                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
12887           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12888           {
12889              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
12890              return NULLP;
12891           }
12892           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
12893
12894           /* Free encoded buffer after decoding */
12895           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
12896       }
12897       free(ueCapRatContList->list.array[idx]);
12898    }
12899
12900    /* Free Memory*/
12901    free(ueCapRatContList->list.array);
12902    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
12903    return ueNrCap;
12904 }
12905
12906 /*******************************************************************
12907 *
12908 * @brief free UE context setup request from CU
12909 *
12910 * @details
12911 *
12912 *    Function : freeAperDecodeF1UeContextSetupReq
12913 *
12914 *    Functionality: freeing part for the memory allocated by aper_decoder
12915 *
12916 * @params[in] F1AP message
12917 * @return ROK     - success
12918 *         RFAILED - failure
12919 *
12920 * ****************************************************************/
12921 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
12922 {
12923    uint8_t ieIdx = 0;
12924
12925    if(ueSetReq->protocolIEs.list.array != NULLP)
12926    {
12927       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
12928       {
12929          if(ueSetReq->protocolIEs.list.array[ieIdx])
12930          {
12931             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
12932             {
12933                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12934                   break;
12935                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12936                   break;
12937                case ProtocolIE_ID_id_SpCell_ID:
12938                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
12939                   break;
12940                case ProtocolIE_ID_id_ServCellIndex:
12941                   break;
12942                case ProtocolIE_ID_id_SpCellULConfigured:
12943                   break;
12944                case ProtocolIE_ID_id_CUtoDURRCInformation:
12945
12946                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
12947                   break;
12948                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
12949
12950                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
12951                   break;
12952                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
12953
12954                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
12955                   break;
12956                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
12957
12958                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
12959                   break;
12960                case ProtocolIE_ID_id_RRCContainer:
12961                   {
12962
12963                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
12964                      {
12965
12966                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
12967                      }
12968                      break;
12969                   }
12970                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12971                   break;
12972                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
12973                   {
12974                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
12975                      {
12976                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
12977                      }
12978                      break;
12979                   }
12980                default:
12981                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
12982             }
12983             free(ueSetReq->protocolIEs.list.array[ieIdx]);
12984          }
12985       }
12986       free(ueSetReq->protocolIEs.list.array);
12987    }
12988 }
12989 /*******************************************************************
12990  *
12991  * @brief Process UE context setup request from CU
12992  *
12993  * @details
12994  *
12995  *    Function : procF1UeContextSetupReq
12996  *
12997  *    Functionality: Process UE context setup request from CU
12998  *
12999  * @params[in] F1AP message
13000  * @return ROK     - success
13001  *         RFAILED - failure
13002  *
13003  * ****************************************************************/
13004 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
13005 {
13006    int8_t ueIdx = -1;
13007    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0, servCellIdx = 0;
13008    bool ueCbFound = false, hoInProgress = false;
13009    uint16_t nrCellId = 0,  cellIdx=0;
13010    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
13011    DuUeCb   *duUeCb = NULL;
13012    UEContextSetupRequest_t   *ueSetReq = NULL;
13013    DRBs_ToBeSetup_List_t *drbCfg = NULL;
13014    CUtoDURRCInformation_t *rrcInfo = NULL;
13015
13016    ret = ROK;
13017
13018    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
13019    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13020    {
13021       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13022       {
13023          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13024             {
13025                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13026                break;
13027             }
13028
13029          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13030             {
13031                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13032                break;
13033             }
13034
13035          case ProtocolIE_ID_id_SpCell_ID:
13036             {
13037                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
13038
13039                GET_CELL_IDX(nrCellId, cellIdx);
13040                if(!duCb.actvCellLst[cellIdx])
13041                {
13042                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%d] not found", nrCellId);
13043                   ret = RFAILED;
13044                }
13045                break;
13046             }
13047
13048          case ProtocolIE_ID_id_ServCellIndex:
13049             {
13050                servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
13051                break;
13052             }
13053
13054          case ProtocolIE_ID_id_SpCellULConfigured:
13055             {
13056                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
13057                   UL, SUL or UL+SUL for the indicated cell for the UE */
13058                break;
13059             }
13060
13061          case ProtocolIE_ID_id_CUtoDURRCInformation:
13062             {
13063                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
13064
13065                /* Search if UE context is present */
13066                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13067                {
13068                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
13069                   {
13070                      ueCbFound = true;
13071                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13072                      break;
13073                   }
13074                }
13075
13076                /* Check if UE Handover scenario */
13077                if(rrcInfo->iE_Extensions)
13078                {
13079                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
13080                   {
13081                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
13082                      {
13083                         hoInProgress = true;
13084                         break;
13085                      }
13086                   }
13087                }
13088
13089                /* If UE context is not present, but UE is in handover */
13090                if(!ueCbFound && hoInProgress)
13091                {
13092                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
13093                   if(ueIdx != -1)
13094                      gnbDuUeF1apId = ueIdx +1;
13095                   else
13096                   {
13097                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%d]", nrCellId);
13098                      ret = RFAILED;
13099                      break;
13100                   }
13101                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13102                   duUeCb->f1UeDb = NULL;
13103                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
13104                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
13105                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
13106                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
13107                }
13108
13109                if(duUeCb)
13110                {
13111                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13112                   if(duUeCb->f1UeDb)
13113                   {
13114                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13115                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
13116                      duUeCb->f1UeDb->cellIdx = cellIdx;
13117                   }
13118                   else
13119                   {
13120                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
13121                      ret = RFAILED;
13122                      break;
13123                   }
13124                }
13125                else
13126                {
13127                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13128                   ret = RFAILED;
13129                   break;
13130                }
13131
13132                /* Extract UE capability info */
13133                if(rrcInfo->uE_CapabilityRAT_ContainerList)
13134                {
13135                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
13136                }
13137
13138                /* Extract IE extension */
13139                if(rrcInfo->iE_Extensions)
13140                {
13141                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
13142                   {
13143                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
13144                      //TODO: Update the failure cause in ue context Setup Response
13145                      ret = RFAILED;
13146                   }
13147                }
13148                break;
13149             }
13150
13151          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
13152             {
13153                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
13154                break;
13155             }
13156
13157          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13158             {
13159                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
13160                         &duUeCb->f1UeDb->duUeCfg))
13161                {
13162                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
13163                   //TODO: Update the failure cause in ue context Setup Response
13164                   ret = RFAILED;
13165                }
13166                break;
13167             }
13168
13169          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13170             {
13171                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
13172
13173                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
13174                {
13175                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
13176                   //TODO: Update the failure cause in ue context Setup Response
13177                   ret = RFAILED;
13178                }
13179                break;
13180             }
13181
13182          case ProtocolIE_ID_id_RRCContainer:
13183             {
13184                /* Filling Dl RRC Msg Info */
13185                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13186                if(!duUeCb->f1UeDb->dlRrcMsg)
13187                {
13188                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
13189                   ret = RFAILED;
13190                }
13191                else
13192                {
13193                   duUeCb->f1UeDb->dlRrcMsgPres = true;
13194                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13195                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13196                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
13197                }
13198                break;
13199             }
13200
13201          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13202             {
13203                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
13204                {
13205                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
13206                }
13207                else
13208                {
13209                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
13210                }
13211                break;
13212             }
13213
13214          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13215             {
13216                /* MaximumBitRate Uplink */
13217                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
13218                if(bitRateSize > 0)
13219                {
13220                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
13221                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
13222                   {
13223                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
13224                      ret = RFAILED;
13225                   }
13226                   else
13227                   {
13228                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
13229                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
13230                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
13231                   }
13232                }
13233                else
13234                   ret = RFAILED;
13235                break;
13236             }
13237
13238          default:
13239             {
13240                break;
13241             }
13242       } /* End of switch */
13243
13244       /* In case of any failure in any IE */
13245       if(ret == RFAILED)
13246       {
13247          // BuildAndSendUeContextSetupRsp(cellId,ueId);
13248          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
13249          break;
13250       }
13251    } /* End of for loop of IEs */
13252
13253    if(ret == ROK)
13254       ret = duProcUeContextSetupRequest(duUeCb);
13255
13256    freeAperDecodeF1UeContextSetupReq(ueSetReq);
13257    return ret;
13258
13259 }
13260 /*******************************************************************
13261  * @brief Free the memory allocated for Dl Tunnel Info
13262  *
13263  * @details
13264  *
13265  *    Function : freeDlTnlInfo
13266  *
13267  *    Functionality:
13268  *       Free the memory allocated for Dl Tunnel Info
13269  *
13270  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
13271  * @return void
13272  *
13273  * ****************************************************************/
13274
13275 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
13276 {
13277    uint8_t arrIdx = 0;
13278
13279    if(tnlInfo)
13280    {
13281       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
13282       {
13283          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
13284                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
13285          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
13286                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
13287          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
13288          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
13289       }
13290       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
13291    }
13292 }
13293
13294 /*******************************************************************
13295  * @brief Free the memory allocated for DRB setup List
13296  *
13297  * @details
13298  *
13299  *    Function : freeDrbSetupList
13300  *
13301  *    Functionality:
13302  *       Free the memory allocated for DRB setup list
13303  *
13304  * @params[in] DRBs_Setup_List_t *
13305  * @return void
13306  *
13307  * ****************************************************************/
13308 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
13309 {
13310    uint8_t arrIdx = 0;
13311    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
13312
13313    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
13314    {
13315       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13316       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
13317       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
13318    }
13319    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
13320 }
13321
13322 /*******************************************************************
13323  * @brief Free the memory allocated for UE Setup response
13324  *
13325  * @details
13326  *
13327  *    Function : FreeUeContextSetupRsp
13328  *
13329  *    Functionality:
13330  *       Free the memory allocated for UE Setup response
13331  *
13332  * @params[in] F1AP PDU for UE setup response
13333  * @return ROK     - success
13334  *         RFAILED - failure
13335  *
13336  * ****************************************************************/
13337 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
13338 {
13339    uint8_t idx;
13340    UEContextSetupResponse_t *ueSetRsp = NULLP;
13341
13342    if(f1apMsg)
13343    {
13344       if(f1apMsg->choice.successfulOutcome)
13345       {
13346          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
13347                     UEContextSetupResponse;
13348          if(ueSetRsp->protocolIEs.list.array)
13349          {
13350             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
13351             {
13352                if(ueSetRsp->protocolIEs.list.array[idx])
13353                {
13354                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
13355                   {
13356                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13357                         break;
13358                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13359                         break;
13360                      case ProtocolIE_ID_id_DUtoCURRCInformation:
13361                         {
13362                            CellGroupConfig_t *cellGrpCfg = NULLP;
13363                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
13364                                          DUtoCURRCInformation.cellGroupConfig;
13365                            if(cellGrpCfg->buf != NULLP)
13366                            {
13367                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
13368                               cellGrpCfg = NULLP;
13369                            }
13370                            break;
13371                         }
13372                     case ProtocolIE_ID_id_DRBs_Setup_List:
13373                         {
13374                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
13375                            break;
13376                         }
13377                      default:
13378                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
13379                         ueSetRsp->protocolIEs.list.array[idx]->id);
13380                         break;
13381                   }
13382                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
13383                         sizeof(UEContextSetupResponseIEs_t));
13384                }
13385             }
13386             DU_FREE(ueSetRsp->protocolIEs.list.array, \
13387                   ueSetRsp->protocolIEs.list.size);
13388          }
13389          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13390       }
13391       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13392    }
13393 }
13394
13395 /*******************************************************************
13396  *
13397  * @brief Builds Ue context Setup Rsp DU To CU Info
13398  *
13399  * @details
13400  *
13401  *    Function : EncodeUeCntxtDuToCuInfo
13402  *
13403  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
13404  *
13405  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
13406  *
13407  * @return ROK     - success
13408  *         RFAILED - failure
13409  *
13410  ******************************************************************/
13411
13412 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
13413 {
13414    asn_enc_rval_t        encRetVal;
13415
13416    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
13417    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
13418    encBufSize = 0;
13419    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
13420    /* Encode results */
13421    if(encRetVal.encoded == ENCODE_FAIL)
13422    {
13423       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
13424             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13425       return RFAILED;
13426    }
13427    else
13428    {
13429       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
13430       for(int i=0; i< encBufSize; i++)
13431       {
13432          printf("%x",encBuf[i]);
13433       }
13434    }
13435    duToCuCellGrp->size = encBufSize;
13436    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
13437    if(!duToCuCellGrp->buf)
13438    {
13439       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
13440    }
13441    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
13442    return ROK;
13443 }
13444
13445 /*******************************************************************
13446  *
13447  * @brief Fills Dl Gtp tunnel Info
13448  *
13449  * @details
13450  *
13451  *    Function : fillGtpTunnelforDl
13452  *
13453  *    Functionality: Fills Dl Gtp tunnel Info
13454  *
13455  * @params[in]
13456  *
13457  * @return ROK     - success
13458  *         RFAILED - failure
13459  *
13460  * ****************************************************************/
13461
13462 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
13463 {
13464    uint8_t bufSize = 0;
13465
13466    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
13467    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
13468    if(gtpDl->transportLayerAddress.buf == NULLP)
13469    {
13470       return RFAILED;
13471    }
13472    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
13473
13474    /*GTP TEID*/
13475    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
13476    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
13477    if(gtpDl->gTP_TEID.buf == NULLP)
13478    {
13479       return RFAILED;
13480    }
13481    bufSize = 3; /*forming an Octect String*/
13482    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
13483
13484    return ROK;
13485 }
13486
13487 /*******************************************************************
13488  *
13489  * @brief Fills DL Tunnel Setup List
13490  *
13491  * @details
13492  *
13493  *    Function : fillDlTnlSetupList
13494  *
13495  *    Functionality: Fills the DL Tunnel Setup List
13496  *
13497  * @params[in]
13498  *
13499  * @return ROK     - success
13500  *         RFAILED - failure
13501  *
13502  * ****************************************************************/
13503
13504 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
13505 {
13506    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
13507
13508    eleCount = 1;
13509    dlTnlInfo->list.count = eleCount;
13510    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
13511
13512    /* Initialize the DL Tnl Setup List Members */
13513    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
13514    if(dlTnlInfo->list.array == NULLP)
13515    {
13516       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
13517       ret = RFAILED;
13518    }
13519    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
13520    {
13521       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
13522       if(dlTnlInfo->list.array[arrIdx] == NULLP)
13523       {
13524          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
13525          return RFAILED;
13526       }
13527       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
13528       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
13529       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
13530       {
13531          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
13532          return RFAILED;
13533       }
13534       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
13535                tnlCfg->tnlCfg1);
13536       if(ret != ROK)
13537          break;
13538    }
13539    return ret;
13540 }
13541
13542 /*******************************************************************
13543  *
13544  * @brief Fills the Drb Setup List for Ue Context Setup Response
13545  *
13546  * @details
13547  *
13548  *    Function : fillDrbSetupList
13549  *
13550  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
13551  *
13552  * @params[in]
13553  *
13554  * @return ROK     - success
13555  *         RFAILED - failure
13556  *
13557  * ****************************************************************/
13558 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
13559 {
13560    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
13561    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
13562
13563    eleCount = ueCfg->numDrb;
13564    drbSetupList->list.count = eleCount;
13565    drbSetupList->list.size = \
13566         (eleCount * sizeof(DRBs_Setup_Item_t *));
13567
13568    /* Initialize the Drb Setup List Members */
13569    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
13570    if(drbSetupList->list.array == NULLP)
13571    {
13572       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
13573       ret = RFAILED;
13574    }
13575
13576    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
13577    {
13578       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
13579       if(drbSetupList->list.array[arrIdx] == NULLP)
13580       {
13581          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
13582          return RFAILED;
13583       }
13584       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13585       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
13586       drbItemIe->criticality = Criticality_reject;
13587       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
13588       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
13589       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
13590           &ueCfg->upTnlInfo[arrIdx]);
13591       if(ret != ROK)
13592          break;
13593    }
13594    return ret;
13595 }
13596
13597 /*******************************************************************
13598  *
13599  * @brief Builds and sends the UE Setup Response
13600  *
13601  * @details
13602  *
13603  *    Function : BuildAndSendUeContextSetupRsp
13604  *
13605  *    Functionality: Constructs the UE Setup Response and sends
13606  *                   it to the DU through SCTP.
13607  *
13608  * @params[in] uint8_t cellId,uint8_t ueId
13609  *
13610  * @return ROK     - success
13611  *         RFAILED - failure
13612  *
13613  * ****************************************************************/
13614 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
13615 {
13616    uint8_t   idx, ret, cellIdx, elementCnt;
13617    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
13618    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
13619    asn_enc_rval_t  encRetVal;        /* Encoder return value */
13620    F1AP_PDU_t               *f1apMsg = NULLP;
13621    UEContextSetupResponse_t *ueSetRsp = NULLP;
13622    DuUeCb                   *ueCb = NULLP;
13623
13624    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
13625
13626    while(true)
13627    {
13628       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13629       if(f1apMsg == NULLP)
13630       {
13631          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
13632          ret = RFAILED;
13633          break;
13634       }
13635
13636       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13637       DU_ALLOC(f1apMsg->choice.successfulOutcome,
13638             sizeof(SuccessfulOutcome_t));
13639       if(f1apMsg->choice.successfulOutcome == NULLP)
13640       {
13641          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
13642          ret = RFAILED;
13643          break;
13644       }
13645
13646       f1apMsg->choice.successfulOutcome->procedureCode = \
13647                                                          ProcedureCode_id_UEContextSetup;
13648       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13649       f1apMsg->choice.successfulOutcome->value.present = \
13650                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
13651
13652       ueSetRsp =
13653          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
13654       elementCnt = 5;
13655       ueSetRsp->protocolIEs.list.count = elementCnt;
13656       ueSetRsp->protocolIEs.list.size = \
13657                                         elementCnt * sizeof(UEContextSetupResponse_t *);
13658
13659       /* Initialize the UESetup members */
13660       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
13661             ueSetRsp->protocolIEs.list.size);
13662       if(ueSetRsp->protocolIEs.list.array == NULLP)
13663       {
13664          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
13665          ret = RFAILED;
13666          break;
13667       }
13668
13669       for(idx=0; idx<elementCnt; idx++)
13670       {
13671          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
13672                sizeof(UEContextSetupResponseIEs_t));
13673          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
13674          {
13675             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
13676             ret = RFAILED;
13677             break;
13678          }
13679       }
13680       /* Fetching Ue Cb Info*/
13681       GET_CELL_IDX(cellId, cellIdx);
13682       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
13683       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
13684       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
13685
13686       idx = 0;
13687       /*GNB CU UE F1AP ID*/
13688       ueSetRsp->protocolIEs.list.array[idx]->id = \
13689                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13690       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13691       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
13692                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
13693       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
13694
13695       /*GNB DU UE F1AP ID*/
13696       idx++;
13697       ueSetRsp->protocolIEs.list.array[idx]->id = \
13698                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13699       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13700       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
13701                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
13702       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
13703
13704
13705       /*DUtoCURRC Information */
13706       idx++;
13707       ueSetRsp->protocolIEs.list.array[idx]->id  = \
13708                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
13709       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13710       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
13711                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
13712       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
13713
13714       /* CRNTI */
13715       idx++;
13716       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
13717       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13718       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
13719       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
13720
13721
13722       /* Drb Setup List */
13723       idx++;
13724       ueSetRsp->protocolIEs.list.array[idx]->id  = \
13725                                                    ProtocolIE_ID_id_DRBs_Setup_List;
13726       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13727       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
13728                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
13729       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
13730             &ueCb->f1UeDb->duUeCfg);
13731       if(ret == RFAILED)
13732       {
13733          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
13734          freeF1UeDb(ueCb->f1UeDb);
13735          ueCb->f1UeDb = NULLP;
13736          break;
13737       }
13738
13739       /* Free UeContext Db created during Ue context Req */
13740       freeF1UeDb(ueCb->f1UeDb);
13741       ueCb->f1UeDb = NULLP;
13742
13743       /* TODO: To send Drb list */
13744       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13745
13746       /* Encode the UE context setup response type as APER */
13747       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
13748       encBufSize = 0;
13749       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
13750             encBuf);
13751       /* Encode results */
13752       if(encRetVal.encoded == ENCODE_FAIL)
13753       {
13754          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
13755                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13756          ret = RFAILED;
13757          break;
13758       }
13759       else
13760       {
13761          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
13762          for(int i=0; i< encBufSize; i++)
13763          {
13764             printf("%x",encBuf[i]);
13765          }
13766       }
13767
13768       /* Sending  msg  */
13769       if(sendF1APMsg()  != ROK)
13770       {
13771          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
13772          ret = RFAILED;
13773          break;
13774       }
13775       break;
13776    }
13777    FreeUeContextSetupRsp(f1apMsg);
13778    return ret;
13779 }/* End of BuildAndSendUeContextSetupRsp */
13780 /*******************************************************************
13781 *
13782 * @brief  Build And Send Ue Context Rsp
13783 *
13784 * @details
13785 *
13786 *    Function : BuildAndSendUeCtxtRsp
13787 *
13788 *    Functionality : Build And Send Ue Context Rsp
13789
13790 * @params[in]
13791 * @return sucess = ROK
13792 *         failure = RFAILED
13793 *
13794 * ****************************************************************/
13795 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
13796 {
13797    uint8_t cellIdx = 0, actionType = 0;
13798
13799    GET_CELL_IDX(cellId, cellIdx);
13800    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
13801
13802    switch(actionType)
13803    {
13804       case UE_CTXT_SETUP:
13805          {
13806             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
13807             {
13808                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
13809                return RFAILED;
13810             }
13811             break;
13812          }
13813       case UE_CTXT_MOD:
13814          {
13815             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
13816             {
13817                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
13818                return RFAILED;
13819             }
13820             break;
13821          }
13822       default:
13823          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
13824          break;
13825
13826    }
13827    return ROK;
13828 }
13829
13830 /*******************************************************************
13831  *
13832  * @brief deallocating the memory of  F1reset msg
13833  *
13834  * @details
13835  *
13836  *    Function : FreeF1ResetReq
13837  *
13838  *    Functionality :
13839  *         - freeing memory of F1reset request msg
13840  *
13841  * @params[in]
13842  * @return void
13843  *
13844  *
13845  * ****************************************************************/
13846 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
13847 {
13848    uint8_t idx =0 ;
13849    Reset_t *f1ResetMsg;
13850
13851    if(f1apMsg)
13852    {
13853       if(f1apMsg->choice.initiatingMessage)
13854       {
13855          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
13856
13857          if(f1ResetMsg->protocolIEs.list.array)
13858          {
13859             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
13860             {
13861                if(f1ResetMsg->protocolIEs.list.array[idx])
13862                {
13863                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
13864                }
13865             }
13866             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
13867          }
13868          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13869       }
13870       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13871    }
13872 }
13873 /*******************************************************************
13874  *
13875  * @brief Build and Send F1reset request
13876  *
13877  * @details
13878  *
13879  *    Function : BuildAndSendF1ResetReq
13880  *
13881  *    Functionality:
13882  *         - Build and Send F1reset request msg
13883  *
13884  * @params[in]
13885  * @return ROK     - success
13886  *         RFAILED - failure
13887  *
13888  * ****************************************************************/
13889 uint8_t BuildAndSendF1ResetReq()
13890 {
13891    uint8_t          elementCnt=0;
13892    uint8_t          idx=0;
13893    uint8_t          ret= RFAILED;
13894    Reset_t          *f1ResetMsg = NULLP;
13895    F1AP_PDU_t       *f1apMsg = NULLP;
13896    asn_enc_rval_t   encRetVal;
13897    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
13898    do
13899    {
13900       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13901       if(f1apMsg == NULLP)
13902       {
13903          break;
13904       }
13905       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13906       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13907       if(f1apMsg->choice.initiatingMessage == NULLP)
13908       {
13909          break;
13910       }
13911       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
13912       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13913       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
13914
13915       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
13916
13917       elementCnt = 3;
13918       f1ResetMsg->protocolIEs.list.count = elementCnt;
13919       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
13920
13921       /* Initialize the F1Setup members */
13922       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
13923       if(f1ResetMsg->protocolIEs.list.array == NULLP)
13924       {
13925          break;
13926       }
13927       for(idx=0; idx<elementCnt; idx++)
13928       {
13929          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
13930          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
13931          {
13932             break;
13933          }
13934       }
13935
13936       /*TransactionID*/
13937       idx=0;
13938       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
13939       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13940       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
13941       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
13942
13943       /*Cause*/
13944       idx++;
13945       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
13946       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
13947       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
13948       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
13949       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
13950
13951       /*Reset Type*/
13952       idx++;
13953       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
13954       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
13955       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
13956       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
13957       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
13958
13959       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13960
13961       /* Encode the F1SetupRequest type as APER */
13962       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13963       encBufSize = 0;
13964       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
13965             encBuf);
13966
13967       /* Encode results */
13968       if(encRetVal.encoded == ENCODE_FAIL)
13969       {
13970          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
13971                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13972          break;
13973       }
13974       else
13975       {
13976          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
13977          for(idx=0; idx< encBufSize; idx++)
13978          {
13979             printf("%x",encBuf[idx]);
13980          }
13981       }
13982
13983       if(sendF1APMsg() != ROK)
13984       {
13985          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
13986          break;
13987       }
13988
13989       ret = ROK;
13990       break;
13991    }while(true);
13992
13993    FreeF1ResetReq(f1apMsg);
13994    return ret;
13995 }
13996 /*******************************************************************
13997  *
13998  * @brief Build And Send F1ResetAck
13999  *
14000  * @details
14001  *
14002  *    Function : BuildAndSendF1ResetAck
14003  *
14004  *    Functionality:
14005  *         - Build And Send  F1ResetRSP
14006  *
14007  * @return ROK     - success
14008  *         RFAILED - failure
14009  *
14010  * ****************************************************************/
14011 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
14012 {
14013    uint8_t idx;
14014    ResetAcknowledge_t *f1ResetAck;
14015
14016    if(f1apMsg)
14017    {
14018       if(f1apMsg->choice.successfulOutcome)
14019       {
14020          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14021
14022          if(f1ResetAck->protocolIEs.list.array)
14023          {
14024             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
14025             {
14026                if(f1ResetAck->protocolIEs.list.array[idx])
14027                {
14028                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14029                }
14030             }
14031             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14032          }
14033          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14034       }
14035       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14036    }
14037 }
14038
14039 /*******************************************************************
14040  *
14041  * @brief Build And Send F1ResetAck
14042  *
14043  * @details
14044  *
14045  *    Function : BuildAndSendF1ResetAck
14046  *
14047  *    Functionality:
14048  *         - Build And Send  F1ResetRSP
14049  *
14050  *  @params[in]
14051  * @return ROK     - success
14052  *         RFAILED - failure
14053  *
14054  * ****************************************************************/
14055 uint8_t BuildAndSendF1ResetAck()
14056 {
14057    uint8_t                idx = 0;
14058    uint8_t                elementCnt = 0;
14059    uint8_t                ret = RFAILED;
14060    F1AP_PDU_t             *f1apMsg = NULL;
14061    ResetAcknowledge_t     *f1ResetAck = NULLP;
14062    asn_enc_rval_t         encRetVal;
14063    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
14064
14065    do{
14066       /* Allocate the memory for F1ResetRequest_t */
14067       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14068       if(f1apMsg == NULLP)
14069       {
14070          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14071          break;
14072       }
14073
14074       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14075
14076       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14077       if(f1apMsg->choice.successfulOutcome == NULLP)
14078       {
14079          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14080          break;
14081       }
14082       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
14083       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
14084       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14085
14086       elementCnt = 1;
14087
14088       f1ResetAck->protocolIEs.list.count = elementCnt;
14089       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
14090
14091       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14092       if(f1ResetAck->protocolIEs.list.array == NULLP)
14093       {
14094          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
14095          break;
14096       }
14097
14098       for(idx=0; idx<elementCnt; idx++)
14099       {
14100          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14101          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
14102          {
14103             break;
14104          }
14105       }
14106       /*TransactionID*/
14107       idx = 0;
14108       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14109       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14110       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
14111       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
14112
14113       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14114
14115       /* Encode the F1SetupRequest type as UPER */
14116       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14117       encBufSize = 0;
14118       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14119
14120       /* Check encode results */
14121       if(encRetVal.encoded == ENCODE_FAIL)
14122       {
14123          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
14124                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14125          break;
14126       }
14127       else
14128       {
14129          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
14130          for(int i=0; i< encBufSize; i++)
14131          {
14132             printf("%x",encBuf[i]);
14133          }
14134       }
14135       /* Sending msg */
14136       if(sendF1APMsg() != ROK)
14137       {
14138          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
14139          break;
14140       }
14141
14142       ret = ROK;
14143       break;
14144    }while(true);
14145
14146    FreeF1ResetAck(f1apMsg);
14147    return ret;
14148 }
14149 /******************************************************************
14150 *
14151 * @brief free F1 reset msg allocated by aper_decoder
14152 *
14153 * @details
14154 *
14155 *    Function : freeAperDecodeF1ResetMsg
14156 *
14157 *    Functionality: free F1 reset msg allocated by aper_decoder
14158 *
14159 * @params[in] Reset_t *f1ResetMsg
14160 * @return void
14161 *
14162 * ****************************************************************/
14163
14164 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
14165 {
14166    uint8_t ieIdx =0;
14167    if(f1ResetMsg->protocolIEs.list.array)
14168    {
14169       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
14170       {
14171          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
14172          {
14173             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
14174          }
14175       }
14176       free(f1ResetMsg->protocolIEs.list.array);
14177    }
14178 }
14179
14180 /******************************************************************
14181  *
14182  * @brief Processes DL RRC Message Transfer  sent by CU
14183  *
14184  * @details
14185  *
14186  *    Function : procF1ResetReq
14187  *
14188  *    Functionality: Processes DL RRC Message Transfer sent by CU
14189  *
14190  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14191  * @return ROK     - success
14192  *         RFAILED - failure
14193  *
14194  * ****************************************************************/
14195 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
14196 {
14197    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
14198    uint8_t       ieIdx = 0;
14199    uint8_t        ret = ROK;
14200    Reset_t       *f1ResetMsg = NULLP;
14201
14202    DU_LOG("\nINFO   -->  Processing F1 reset request");
14203    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14204
14205    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
14206    {
14207       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
14208       {
14209          case ProtocolIE_ID_id_TransactionID:
14210             break;
14211
14212          case ProtocolIE_ID_id_Cause:
14213             break;
14214
14215          case ProtocolIE_ID_id_ResetType:
14216             {
14217                break;
14218             }
14219
14220          default:
14221             break;
14222       }
14223    }
14224    ret = BuildAndSendF1ResetAck();
14225    DU_LOG("\nINFO   -->  UE release is not supported for now");
14226
14227    freeAperDecodeF1ResetMsg(f1ResetMsg);
14228
14229    return ret;
14230 }
14231
14232 /*******************************************************************
14233  *
14234  * @brief free the RRC delivery report
14235  *
14236  * @details
14237  *
14238  *    Function : freeRrcDeliveryReport
14239  *
14240  *    Functionality: free the RRC delivery report
14241  *
14242  * @params[in]
14243  * @return ROK     - success
14244  *         RFAILED - failure
14245  *
14246  * ****************************************************************/
14247 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
14248 {
14249    uint8_t idx=0;
14250    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14251
14252    if(f1apMsg)
14253    {
14254       if(f1apMsg->choice.initiatingMessage)
14255       {
14256          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14257          if(rrcDeliveryReport->protocolIEs.list.array)
14258          {
14259             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
14260                   idx++)
14261             {
14262                if(rrcDeliveryReport->protocolIEs.list.array[idx])
14263                {
14264                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
14265                         sizeof(RRCDeliveryReportIEs_t));
14266                }
14267             }
14268             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
14269                   rrcDeliveryReport->protocolIEs.list.size);
14270          }
14271          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14272       }
14273       DU_FREE(f1apMsg,
14274             sizeof(F1AP_PDU_t));
14275    }
14276 }
14277
14278 /*******************************************************************
14279 *
14280 * @brief Builds and sends the RRC delivery report
14281 *
14282 * @details
14283 *
14284 *    Function : BuildAndSendRrcDeliveryReport
14285 *
14286 *    Functionality: Builds and sends the RRC delivery report
14287 *
14288 * @params[in]
14289 *
14290 * @return ROK     - success
14291 *         RFAILED - failure
14292 *
14293 * ****************************************************************/
14294 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
14295    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
14296 {
14297    uint8_t             ret = RFAILED;
14298    uint8_t             idx    = 0;
14299    uint8_t             idx1   = 0;
14300    uint8_t             elementCnt = 0;
14301    F1AP_PDU_t          *f1apMsg = NULLP;
14302    asn_enc_rval_t      encRetVal;
14303    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14304
14305    do{
14306
14307       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
14308       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14309       if(f1apMsg == NULLP)
14310       {
14311          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14312          break;
14313       }
14314       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14315       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14316       if(f1apMsg->choice.initiatingMessage == NULLP)
14317       {
14318          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
14319          break;
14320       }
14321       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
14322       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
14323       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
14324
14325       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14326       elementCnt = 4;
14327       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
14328       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
14329
14330       /* Initialize the F1Setup members */
14331       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
14332       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
14333       {
14334          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
14335          break;
14336       }
14337       for(idx =0 ;idx <elementCnt; idx++)
14338       {
14339          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
14340          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
14341          {
14342             break;
14343          }
14344       }
14345
14346       idx1 = 0;
14347
14348       /*GNB CU UE F1AP ID*/
14349       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14350       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14351       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
14352       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14353
14354       /*GNB DU UE F1AP ID*/
14355       idx1++;
14356       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14357       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14358       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
14359       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14360
14361       /*RRC delivery status*/
14362       idx1++;
14363       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
14364       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14365       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
14366       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
14367       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
14368       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
14369       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
14370
14371       /* SRB ID */
14372       idx1++;
14373       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
14374       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14375       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
14376       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
14377
14378       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14379
14380       /* Encode the RRC DELIVERY REPORT type as APER */
14381       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14382       encBufSize = 0;
14383       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14384             encBuf);
14385
14386       /* Encode results */
14387       if(encRetVal.encoded == ENCODE_FAIL)
14388       {
14389          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
14390                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14391          break;
14392       }
14393       else
14394       {
14395          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
14396          for(idx=0; idx< encBufSize; idx++)
14397          {
14398             printf("%x",encBuf[idx]);
14399          }
14400       }
14401
14402       /* Sending msg */
14403       if(sendF1APMsg() != ROK)
14404       {
14405          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
14406          break;
14407       }
14408       ret = ROK;
14409       break;
14410
14411    }while(true);
14412
14413    freeRrcDeliveryReport(f1apMsg);
14414    return ret;
14415 }
14416
14417 /*******************************************************************
14418  *
14419  * @brief Processes cells to be activated
14420  *
14421  * @details
14422  *
14423  *    Function : extractCellsToBeActivated
14424  *
14425  *    Functionality:
14426  *      - Processes cells to be activated list received in F1SetupRsp
14427  *
14428  * @params[in] void
14429  * @return ROK     - success
14430  *         RFAILED - failure
14431  *
14432  * ****************************************************************/
14433
14434 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
14435 {
14436    uint8_t  ret = ROK;
14437    uint16_t idx, nci, pci = 0;
14438    Cells_to_be_Activated_List_Item_t cell;
14439
14440    for(idx=0; idx<cellsToActivate.list.count; idx++)
14441    {
14442       nci = 0;
14443       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
14444       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
14445
14446       if(cell.nRPCI)
14447       {
14448          pci = *cell.nRPCI;
14449       }
14450       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
14451    }
14452    return ret;
14453 }
14454 /******************************************************************
14455 *
14456 * @brief Processes F1 Setup Response allocated by aper_decoder
14457 *
14458 * @details
14459 *
14460 *    Function : freeF1SetupRsp
14461 *
14462 *    Functionality: free F1 Setup Response allocated by aper_decoder
14463 *
14464 * @params[in] F1SetupResponse_t *f1SetRspMsg
14465 * @return void
14466 *
14467 * ****************************************************************/
14468
14469 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
14470 {
14471    uint8_t ieIdx =0;
14472    uint8_t arrIdx =0;
14473    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
14474    RRC_Version_t      *rrcVer =NULLP;
14475
14476    if(f1SetRspMsg->protocolIEs.list.array)
14477    {
14478       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
14479       {
14480          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
14481          {
14482             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
14483             {
14484                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
14485                   {
14486                      cellToActivate =
14487                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
14488                      if(cellToActivate->list.array)
14489                      {
14490                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
14491                         {
14492                            if(cellToActivate->list.array[arrIdx])
14493                            {
14494
14495                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
14496                               pLMN_Identity.buf)
14497                               {
14498                                  if(cellToActivate->list.array[0]->value.choice.\
14499                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
14500                                  {
14501                                     free(cellToActivate->list.array[0]->value.choice.\
14502                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
14503                                  }
14504
14505                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
14506                                        nRCGI.pLMN_Identity.buf);
14507                               }
14508                               free(cellToActivate->list.array[arrIdx]);
14509                            }
14510                         }
14511                         free(cellToActivate->list.array);
14512                      }
14513                      break;
14514                   }
14515                case ProtocolIE_ID_id_TransactionID:
14516                   {
14517                      break;
14518                   }
14519                case ProtocolIE_ID_id_gNB_CU_Name:
14520                   {
14521                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
14522                      break;
14523                   }
14524                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
14525                   {
14526                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
14527                      if(rrcVer->latest_RRC_Version.buf)
14528                      {
14529                         if(rrcVer->iE_Extensions)
14530                         {
14531                            if(rrcVer->iE_Extensions->list.array)
14532                            {
14533                               if(rrcVer->iE_Extensions->list.array[0])
14534                               {
14535                                  if(rrcVer->iE_Extensions->list.\
14536                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
14537                                  {
14538                                     free(rrcVer->iE_Extensions->list.\
14539                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
14540                                  }
14541                                  free(rrcVer->iE_Extensions->list.array[0]);
14542                               }
14543                               free(rrcVer->iE_Extensions->list.array);
14544                            }
14545                            free(rrcVer->iE_Extensions);
14546                         }
14547                         free(rrcVer->latest_RRC_Version.buf);
14548                      }
14549                      break;
14550
14551                   }
14552                default:
14553                   {
14554                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
14555                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
14556                   }
14557             }
14558             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
14559          }
14560       }
14561       free(f1SetRspMsg->protocolIEs.list.array);
14562    }
14563 }
14564 /******************************************************************
14565  *
14566  * @brief Processes F1 Setup Response sent by CU
14567  *
14568  * @details
14569  *
14570  *    Function : procF1SetupRsp
14571  *
14572  *    Functionality: Processes F1 Setup Response sent by CU
14573  *
14574  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14575  * @return ROK     - success
14576  *         RFAILED - failure
14577  *
14578  * ****************************************************************/
14579 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
14580 {
14581    uint8_t ret = ROK;
14582    uint16_t idx =0;
14583    F1SetupResponse_t *f1SetRspMsg = NULLP;
14584    GNB_CU_Name_t     *cuName = NULLP;
14585    F1SetupRsp  f1SetRspDb;
14586    RRC_Version_t      *rrcVer =NULLP;
14587
14588    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
14589
14590    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
14591    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
14592
14593    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
14594    {
14595       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
14596       {
14597          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
14598             {
14599                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
14600                      value.choice.Cells_to_be_Activated_List);
14601                break;
14602             }
14603          case ProtocolIE_ID_id_TransactionID:
14604             {
14605                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
14606                                     value.choice.TransactionID;
14607                break;
14608             }
14609          case ProtocolIE_ID_id_gNB_CU_Name:
14610             {
14611                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
14612                         value.choice.GNB_CU_Name;
14613                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
14614                break;
14615             }
14616          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
14617             {
14618                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
14619                strcpy(f1SetRspDb.rrcVersion.rrcVer,
14620                      (const char*)rrcVer->latest_RRC_Version.buf);
14621                break;
14622             }
14623          default:
14624             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
14625                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
14626       }
14627       duProcF1SetupRsp();
14628    }
14629
14630    freeAperDecodeF1SetupRsp(f1SetRspMsg);
14631
14632    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
14633    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
14634    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
14635    {
14636       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
14637       return RFAILED;
14638    }
14639    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
14640
14641    if(BuildAndSendE2SetupReq() != ROK)
14642    {
14643       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
14644       return RFAILED;
14645    }
14646    return ret;
14647 }
14648 /*******************************************************************
14649 *
14650 * @brief free GNB DU config update ack
14651 *
14652 * @details
14653 *
14654 *    Function : freeAperDecodeGnbDuAck
14655 *
14656 *    Functionality: Processes GNB DU config update ack And
14657 *                     added free part for the memory allocated by aper_decoder
14658 *
14659 * @params[in] F1AP_PDU_t ASN decoded F1AP message
14660 * @return ROK     - success
14661 *         RFAILED - failure
14662 *
14663 * ****************************************************************/
14664
14665 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
14666 {
14667    uint8_t ieIdx = 0;
14668
14669    if(gnbDuAck->protocolIEs.list.array)
14670    {
14671       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
14672       {
14673          if(gnbDuAck->protocolIEs.list.array[ieIdx])
14674          {
14675             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
14676          }
14677       }
14678       free(gnbDuAck->protocolIEs.list.array);
14679    }
14680 }
14681
14682 /*******************************************************************
14683 *
14684 * @brief Building  result of gnb-du config update ack output
14685 *
14686 * @details
14687 *
14688 *    Function : duProcGnbDuCfgUpdAckMsg
14689 *
14690 *    Functionality:
14691 *        Building output of gnb-du config update ack
14692 *
14693 * @params[in] transId
14694 * @return void
14695 *
14696 * ****************************************************************/
14697
14698 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
14699 {
14700    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
14701    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
14702    uint16_t cellId =0, cellIdx =0, crnti=0;
14703    CmLList *f1apPduNode = NULLP;
14704    ReservedF1apPduInfo *f1apPduInfo =NULLP;
14705    F1AP_PDU_t *f1apMsgPdu = NULLP;
14706    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
14707    BIT_STRING_t *cellIdentity=NULLP;
14708    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
14709    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
14710    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
14711
14712    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
14713    f1apPduNode = searchFromReservedF1apPduList(transId);
14714    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
14715    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
14716
14717    if(f1apMsgPdu)
14718    {
14719       if(f1apMsgPdu->choice.initiatingMessage)
14720       {
14721          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
14722          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
14723          {
14724             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
14725             {
14726                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
14727                   {
14728                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
14729                                      Served_Cells_To_Delete_List;
14730                      if(cellsToDelete->list.array)
14731                      {
14732                         if(cellsToDelete->list.array[arrIdx])
14733                         {
14734                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
14735                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
14736                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
14737                            {
14738                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
14739                               bitStringToInt(cellIdentity, &cellId);
14740
14741                               GET_CELL_IDX(cellId, cellIdx);
14742                               if(duCb.actvCellLst[cellIdx] != NULLP)
14743                               {
14744                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
14745                               }
14746                            }
14747                         }
14748                      }
14749
14750                      if(duCb.actvCellLst[cellIdx] != NULLP)
14751                      {
14752                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
14753                         {
14754                            ret = duSendCellDeletReq(cellId);
14755                            if(ret == RFAILED)
14756                            {
14757                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
14758                               request for cellId[%d]", cellId);
14759                            }
14760                         }
14761                         else
14762                         {
14763                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
14764                            while(totalActiveUe)
14765                            {
14766                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
14767                               {
14768                                  ueIdx++;
14769                                  continue;
14770                               }
14771
14772                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
14773                               GET_UE_ID(crnti,ueId);
14774                               /* Sending Ue Context release request only for maximum supporting UEs */
14775                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
14776                               if(ret == RFAILED)
14777                               {
14778                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
14779                                  request for cellId[%d]", cellId);
14780                               }
14781                               ueIdx++;
14782                               totalActiveUe--;
14783                            }
14784                         }
14785                      }
14786                      else
14787                      {
14788                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
14789                         ret = RFAILED;
14790                      }
14791                      break;
14792                   }
14793
14794                default:
14795                   break;
14796             }
14797          }
14798       }
14799    }
14800
14801    FreeDUConfigUpdate(f1apMsgPdu);
14802    deleteFromReservedF1apPduList(f1apPduNode);
14803    return ret;
14804 }
14805
14806 /*******************************************************************
14807 *
14808 * @brief Processes GNB DU config update ack
14809 *
14810 * @details
14811 *
14812 *    Function : procF1GNBDUCfgUpdAck
14813 *
14814 *    Functionality: added free part for the memory allocated by aper_decoder
14815 *
14816 * @params[in] F1AP_PDU_t *f1apMsg
14817 * @return void
14818 *
14819 * ****************************************************************/
14820 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
14821 {
14822    uint8_t ieIdx=0,transId=0;
14823    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
14824
14825    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
14826    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
14827
14828    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
14829    {
14830       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
14831       {
14832          case ProtocolIE_ID_id_TransactionID:
14833             {
14834                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
14835                break;
14836             }
14837          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
14838             {
14839                break;
14840             }
14841          default :
14842             {
14843                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
14844                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
14845                break;
14846             }
14847       }
14848    }
14849
14850    duProcGnbDuCfgUpdAckMsg(transId);
14851
14852 #if 0
14853    /* presently we are not supporting F1 Reset from DU to CU , we are only
14854     * supporting F1 Reset from CU to DU */
14855
14856    if(BuildAndSendF1ResetReq() != ROK)
14857    {
14858       return RFAILED;
14859    }
14860 #endif
14861
14862    freeAperDecodeGnbDuAck(gnbDuAck);
14863    return ROK;
14864 }
14865 /******************************************************************
14866 *
14867 * @brief free DL RRC Message Transfer allocated by aper_decoder
14868 *
14869 * @details
14870 *
14871 *    Function : freeAperDecodef1DlRrcMsg
14872 *
14873 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
14874 *
14875 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
14876 * @return ROK     - success
14877 *         RFAILED - failure
14878 *
14879 * ****************************************************************/
14880
14881 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
14882 {
14883    uint8_t ieIdx =0;
14884    RRCContainer_t *rrcContainer = NULLP;
14885
14886    if(f1DlRrcMsg->protocolIEs.list.array)
14887    {
14888       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
14889       {
14890          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
14891          {
14892             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
14893             {
14894                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14895                   break;
14896                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14897                   break;
14898                case ProtocolIE_ID_id_SRBID:
14899                   break;
14900                case ProtocolIE_ID_id_RRCContainer:
14901                   {
14902                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
14903                      free(rrcContainer->buf);
14904                   }
14905                case ProtocolIE_ID_id_ExecuteDuplication:
14906                   break;
14907                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
14908                   break;
14909                   break;
14910             }
14911             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
14912          }
14913       }
14914       free(f1DlRrcMsg->protocolIEs.list.array);
14915    }
14916 }
14917 /******************************************************************
14918  *
14919  * @brief Processes DL RRC Message Transfer  sent by CU
14920  *
14921  * @details
14922  *
14923  *    Function : procF1DlRrcMsgTrans
14924  *
14925  *    Functionality: Processes DL RRC Message Transfer sent by CU
14926  *
14927  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14928  * @return ROK     - success
14929  *         RFAILED - failure
14930  *
14931  * ****************************************************************/
14932 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
14933 {
14934    uint8_t  idx, ret;
14935    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
14936    F1DlRrcMsg dlMsg;
14937    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
14938
14939    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
14940    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
14941
14942    ret = ROK;
14943
14944    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
14945    {
14946       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
14947       {
14948          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14949             {
14950                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
14951                break;
14952             }
14953          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14954             {
14955                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
14956                break;
14957             }
14958          case ProtocolIE_ID_id_SRBID:
14959             {
14960                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
14961                break;
14962             }
14963          case ProtocolIE_ID_id_ExecuteDuplication:
14964             dlMsg.execDup = true;
14965             break;
14966
14967          case ProtocolIE_ID_id_RRCContainer:
14968             {
14969                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
14970                {
14971                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
14972                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
14973                   if(dlMsg.rrcMsgPdu)
14974                   {
14975                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
14976                         dlMsg.rrcMsgSize);
14977                   }
14978                   else
14979                   {
14980                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
14981                      return RFAILED;
14982                   }
14983                }
14984                else
14985                {
14986                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
14987                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
14988                   return RFAILED;
14989                }
14990                break;
14991             }
14992          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
14993             {
14994                dlMsg.deliveryStatRpt = true;
14995                break;
14996             }
14997          default:
14998             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
14999                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
15000       }
15001    }
15002
15003    ret = duProcDlRrcMsg(&dlMsg);
15004
15005    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
15006    return ret;
15007 }
15008 /*******************************************************************
15009  *
15010 * @brief Builds the DRB to be Setup Mod list
15011 *
15012 * @details
15013 *
15014 *    Function :
15015 *
15016 *    Functionality: Constructs the DRB to be Setup Mod list
15017 *
15018 * @params[in] DRBs_SetupMod_List_t *drbSet
15019 *
15020 * @return ROK     - success
15021 *         RFAILED - failure
15022 *
15023 * ****************************************************************/
15024 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
15025 {
15026    uint8_t srbIdx = 0;
15027    struct SRBs_SetupMod_ItemIEs *srbItemIe;
15028
15029    srbList->list.count = ueCfg->numRlcLcs;
15030    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
15031
15032    DU_ALLOC(srbList->list.array, srbList->list.size);
15033    if(srbList->list.array == NULLP)
15034    {
15035       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15036       return RFAILED;
15037    }
15038
15039    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
15040    {
15041       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15042       if(srbList->list.array[srbIdx] == NULLP)
15043       {
15044          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15045          return RFAILED;
15046       }
15047    }
15048
15049    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
15050    {
15051       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
15052       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
15053       srbItemIe->criticality = Criticality_reject;
15054       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
15055       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
15056       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
15057    }
15058    return ROK;
15059 }
15060
15061 /*******************************************************************
15062  *
15063 * @brief Builds the DRB to be Setup Mod list
15064 *
15065 * @details
15066 *
15067 *    Function :
15068 *
15069 *    Functionality: Constructs the DRB to be Setup Mod list
15070 *
15071 * @params[in] DRBs_SetupMod_List_t *drbSet
15072 *
15073 * @return ROK     - success
15074 *         RFAILED - failure
15075 *
15076 * ****************************************************************/
15077
15078 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
15079 {
15080    uint8_t arrIdx =0;
15081    uint8_t drbCnt =0;
15082    struct DRBs_SetupMod_ItemIEs *drbItemIe;
15083
15084    drbCnt = ueCfg->numDrbSetupMod;
15085
15086    if(!drbCnt)
15087    {
15088       DU_LOG("\nINFO  -->  F1AP : BuildDrbToBeSetupModList(): No DRB information to avaialble to add");
15089       return ROK;
15090    }
15091
15092    drbSet->list.count = drbCnt;
15093    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
15094    DU_ALLOC(drbSet->list.array, drbSet->list.size);
15095    if(drbSet->list.array == NULLP)
15096    {
15097       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15098       return  RFAILED;
15099    }
15100    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
15101    {
15102       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15103       if(drbSet->list.array[arrIdx] == NULLP)
15104       {
15105               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15106               return  RFAILED;
15107       }
15108
15109       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
15110       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
15111       drbItemIe->criticality = Criticality_reject;
15112       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
15113       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
15114       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
15115       &ueCfg->upTnlInfo[arrIdx])!= ROK)
15116       {
15117          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
15118          return RFAILED;
15119       }
15120
15121    }
15122
15123    return ROK;
15124 }
15125 /*******************************************************************
15126 * @brief Free the memory allocated for DRB setup List
15127 *
15128 * @details
15129 *
15130 *    Function : FreeDrbSetupModList
15131 *
15132 *    Functionality:
15133 *       Free the memory allocated for DRB setup list
15134 *
15135 * @params[in] DRBs_Setup_List_t *
15136 * @return void
15137 *
15138 * ****************************************************************/
15139 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
15140 {
15141    uint8_t arrIdx = 0;
15142    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
15143
15144    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
15145    {
15146       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
15147       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
15148       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15149    }
15150    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
15151 }
15152
15153 /*******************************************************************
15154 * @brief Free the memory allocated for SRB setup List
15155 *
15156 * @details
15157 *
15158 *    Function : FreeSrbSetupModList
15159 *
15160 *    Functionality:
15161 *       Free the memory allocated for SRB setup list
15162 *
15163 * @params[in] SRBs_Setup_List_t *
15164 * @return void
15165 *
15166 * ****************************************************************/
15167 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
15168 {
15169    uint8_t srbIdx = 0;
15170
15171    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
15172       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15173    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
15174 }
15175
15176 /*******************************************************************
15177 * @brief Free the memory allocated for UE Context Mod Response
15178 *
15179 * @details
15180 *
15181 *    Function : FreeUeContextModResp
15182 *
15183 *    Functionality:
15184 *       Free the memory allocated for UE Context Mod Response
15185 *
15186 * @params[in] F1AP_PDU_t *f1apMsg
15187 * @return void
15188 *
15189 * ****************************************************************/
15190
15191 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
15192 {
15193    uint8_t ieIdx;
15194    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15195    if(f1apMsg)
15196    {
15197       if(f1apMsg->choice.successfulOutcome)
15198       {
15199          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15200          if(ueContextModifyRes->protocolIEs.list.array)
15201          {
15202             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
15203             {
15204                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
15205                {
15206                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
15207                   {
15208                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15209                         break;
15210                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15211                         break;
15212                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
15213                         {
15214                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15215                             value.choice.DRBs_SetupMod_List));
15216                             break;
15217                         }
15218                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
15219                         {
15220                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
15221                               SRBs_SetupMod_List));
15222                            break;
15223                         }
15224                   }
15225                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15226                }
15227
15228             }
15229             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15230          }
15231          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15232       }
15233       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15234    }
15235 }
15236
15237 /*****************************************************************i
15238 *
15239 * @brief Creating the ue context modifcation response and sending
15240 *
15241 * @details
15242 *
15243 *    Function : BuildAndSendUeContextModRsp
15244 *
15245 *    Functionality:
15246 *         - Creating the ue context modifcation response
15247 *
15248 * @params[in] uint8_t cellId,uint8_t ueId
15249 * @return ROK     - success
15250 *         RFAILED - failure
15251 *
15252 * ****************************************************************/
15253 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
15254 {
15255    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
15256    uint8_t   elementCnt = 0;
15257    uint8_t   ret = RFAILED;
15258    F1AP_PDU_t *f1apMsg = NULLP;
15259    asn_enc_rval_t  encRetVal;
15260    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15261
15262    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
15263
15264    while(1)
15265    {
15266       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15267       if(f1apMsg == NULLP)
15268       {
15269          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15270          break;
15271       }
15272
15273       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
15274
15275       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15276       if(f1apMsg->choice.successfulOutcome == NULLP)
15277       {
15278          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15279          break;
15280       }
15281       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
15282       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
15283       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
15284
15285       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15286
15287       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
15288       {
15289          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
15290             elementCnt =3;
15291          else
15292             elementCnt =2;
15293       }
15294       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15295          elementCnt = 5;
15296       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
15297          elementCnt = 2;
15298       ueContextModifyRes->protocolIEs.list.count = elementCnt;
15299       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
15300
15301       /* Initialize the UE context modification members */
15302       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15303       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
15304       {
15305          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15306          break;
15307       }
15308
15309       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
15310       {
15311          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15312          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
15313          {
15314             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15315             break;
15316          }
15317       }
15318
15319       ieIdx=0;
15320       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15321       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15322       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15323       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
15324       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
15325
15326       ieIdx++;
15327       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15328       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15329       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
15330       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
15331       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
15332
15333       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15334       {
15335          ieIdx++;
15336          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
15337          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15338          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15339          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
15340          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
15341       }
15342
15343       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
15344       {
15345          ieIdx++;
15346          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
15347          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15348          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15349                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
15350          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15351          {
15352             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
15353             {
15354                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
15355                {
15356                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
15357                }
15358             }
15359          }
15360          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15361                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
15362          if(ret != ROK)
15363          {
15364             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
15365             break;
15366          }
15367       }
15368
15369       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15370       {
15371          ieIdx++;
15372          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
15373          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15374          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15375                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
15376          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
15377          {
15378             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
15379             {
15380                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
15381                      sizeof(RlcBearerCfg));
15382             }
15383          }
15384          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
15385                &ueCb->f1UeDb->duUeCfg);
15386          if(ret != ROK)
15387          {
15388             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
15389             break;
15390          }
15391       }
15392
15393       freeF1UeDb(ueCb->f1UeDb);
15394       ueCb->f1UeDb = NULLP;
15395
15396       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15397
15398       /* Encode the F1SetupRequest type as APER */
15399       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15400       encBufSize = 0;
15401       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
15402
15403       /* Encode results */
15404       if(encRetVal.encoded == ENCODE_FAIL)
15405       {
15406          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
15407                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15408          ret = RFAILED;
15409          break;
15410       }
15411       else
15412       {
15413          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
15414          for(int i=0; i< encBufSize; i++)
15415          {
15416             printf("%x",encBuf[i]);
15417          }
15418       }
15419
15420       /* Sending  msg  */
15421       if(sendF1APMsg() != ROK)
15422       {
15423          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
15424          ret = RFAILED;
15425          break;
15426       }
15427
15428       ret = ROK;
15429       break;
15430    }
15431    FreeUeContextModResp(f1apMsg);
15432    return ret;
15433 }
15434 /*******************************************************************
15435  *
15436  * @brief Deallocating the memory allocated by the aper decoder
15437  *          for QOSInfo
15438  *
15439  * @details
15440  *
15441  *    Function : freeAperDecodeQosInfo
15442  *
15443  *    Functionality:  Deallocating the memory allocated for QOSInfo
15444  *
15445  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
15446  *
15447  * @return void
15448  *
15449  * ****************************************************************/
15450
15451 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
15452 {
15453    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
15454    {
15455       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
15456       {
15457          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
15458          {
15459             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
15460          }
15461          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
15462       }
15463       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
15464    }
15465 }
15466 /*******************************************************************
15467  *
15468  * @brief Deallocating the memory allocated by the aper decoder
15469  *          for UlTnlInfoforDrb
15470  *
15471  * @details
15472  *
15473  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
15474  *
15475  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
15476  *
15477  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
15478  *
15479  * @return void
15480  *
15481  * ****************************************************************/
15482 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
15483 {
15484    uint8_t arrIdx =0;
15485
15486    if(ulInfo->list.array)
15487    {
15488       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
15489       {
15490          if(ulInfo->list.array[arrIdx])
15491          {
15492             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
15493             {
15494                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
15495                {
15496                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
15497                   {
15498                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
15499                            gTP_TEID.buf);
15500                   }
15501                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
15502                         transportLayerAddress.buf);
15503                }
15504                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
15505             }
15506             free(ulInfo->list.array[arrIdx]);
15507          }
15508       }
15509       free(ulInfo->list.array);
15510    }
15511 }
15512 /*******************************************************************
15513  *
15514  * @brief Deallocating the memory allocated by the aper decoder
15515  *          for DrbSetupModItem
15516  *
15517  * @details
15518  *
15519  *    Function : freeAperDecodeDrbSetupModItem
15520  *
15521  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
15522  *
15523  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
15524  *
15525  * @return void
15526  *
15527  * ****************************************************************/
15528
15529 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
15530 {
15531    uint8_t arrIdx =0;
15532    SNSSAI_t *snssai =NULLP;
15533    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
15534
15535    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
15536    switch(drbItem->qoSInformation.present)
15537    {
15538       case QoSInformation_PR_NOTHING:
15539          break;
15540       case QoSInformation_PR_eUTRANQoS:
15541          {
15542             if(drbItem->qoSInformation.choice.eUTRANQoS)
15543             {
15544                free(drbItem->qoSInformation.choice.eUTRANQoS);
15545             }
15546             break;
15547          }
15548       case QoSInformation_PR_choice_extension:
15549          {
15550             if(drbItem->qoSInformation.choice.choice_extension)
15551             {
15552                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
15553                      DRB_Information.dRB_QoS);
15554                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
15555                if(snssai->sST.buf)
15556                {
15557                   free(snssai->sST.buf);
15558                }
15559                if(snssai->sD)
15560                {
15561                   if(snssai->sD->buf)
15562                   {
15563                      free(snssai->sD->buf);
15564                   }
15565                   free(snssai->sD);
15566                }
15567
15568                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
15569                          DRB_Information.flows_Mapped_To_DRB_List;
15570                if(flowMap->list.array)
15571                {
15572                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
15573                   {
15574                      if(flowMap->list.array[arrIdx] )
15575                      {
15576                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
15577                         free(flowMap->list.array[arrIdx]);
15578                      }
15579                   }
15580                   free(flowMap->list.array);
15581                }
15582
15583                free(drbItem->qoSInformation.choice.choice_extension);
15584             }
15585             break;
15586          }
15587
15588    }
15589    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
15590    if(drbItem->uLConfiguration)
15591    {
15592       free(drbItem->uLConfiguration);
15593    }
15594 }
15595
15596 /*******************************************************************
15597  *
15598  * @brief Deallocating the memory allocated by the aper decoder
15599  *          for DrbToBeSetupModList
15600  *
15601  * @details
15602  *
15603  *    Function : freeAperDecodeDrbToBeSetupModList
15604  *
15605  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
15606  *
15607  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
15608  *
15609  * @return void
15610  *
15611  * ****************************************************************/
15612
15613 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
15614 {
15615    uint8_t arrIdx =0;
15616    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
15617
15618    if(drbSet->list.array)
15619    {
15620       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
15621       {
15622          if(drbSet->list.array[arrIdx] != NULLP)
15623          {
15624             if(arrIdx == 0)
15625             {
15626                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
15627                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
15628             }
15629             free(drbSet->list.array[arrIdx]);
15630          }
15631       }
15632       free(drbSet->list.array);
15633    }
15634
15635 }
15636 /*******************************************************************
15637  *
15638  * @brief Deallocating the memory allocated by the aper decoder
15639  *          for UeContextModificationReqMsg
15640  *
15641  * @details
15642  *
15643  *    Function : freeAperDecodeUeContextModificationReqMsg
15644  *
15645  *    Functionality:  Deallocating memory allocated for
15646  *                  UeContextModificationReqMsg
15647  *
15648  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
15649  *
15650  * @return void
15651  *
15652  * ****************************************************************/
15653 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
15654 {
15655    uint8_t arrIdx, ieId;
15656
15657    if(ueContextModifyReq->protocolIEs.list.array)
15658    {
15659       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
15660       {
15661          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
15662          {
15663             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
15664             switch(ieId)
15665             {
15666                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15667                   break;
15668                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15669                   break;
15670                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
15671                   {
15672                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
15673                            value.choice.DRBs_ToBeSetupMod_List);
15674                      break;
15675                   }
15676                case ProtocolIE_ID_id_TransmissionActionIndicator:
15677                   break;
15678                case ProtocolIE_ID_id_RRCContainer:
15679                   {
15680                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
15681                   }
15682             }
15683             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
15684          }
15685       }
15686       free(ueContextModifyReq->protocolIEs.list.array);
15687    }
15688 }
15689 /*******************************************************************
15690  *
15691  * @brief processing the F1 UeContextModificationReq
15692  *
15693  * @details
15694  *
15695  *    Function : procF1UeContextModificationReq
15696  *
15697  *    Functionality:  processing the F1 UeContextModificationReq
15698  *
15699  * @params[in] F1AP_PDU_t *f1apMsg
15700  *
15701  * @return
15702  * ****************************************************************/
15703 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
15704 {
15705    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
15706    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
15707    DuUeCb   *duUeCb = NULLP;
15708    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
15709    DRBs_ToBeModified_List_t *drbModifiedCfg;
15710    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
15711
15712    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
15713    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
15714    {
15715       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
15716       {
15717          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15718             {
15719                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
15720                break;
15721             }
15722          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15723             {
15724                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
15725                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
15726                {
15727                   if(duCb.actvCellLst[cellIdx])
15728                   {
15729                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
15730                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
15731                      {
15732                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
15733                         if(duUeCb->f1UeDb == NULLP)
15734                         {
15735                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
15736                            duUeCb->f1UeDb->cellIdx = cellIdx;
15737                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
15738                         }
15739                         break;
15740                      }
15741                   }
15742                }
15743                if(duUeCb == NULLP)
15744                {
15745                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
15746                   ret = RFAILED;
15747                }
15748                break;
15749             }
15750
15751          case ProtocolIE_ID_id_RRCContainer:
15752             {
15753                /* Filling Dl RRC Msg Info */
15754                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
15755                if(!duUeCb->f1UeDb->dlRrcMsg)
15756                {
15757                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
15758                         Memory allocation failed ");
15759                   ret = RFAILED;
15760                }
15761                else
15762                {
15763                   duUeCb->f1UeDb->dlRrcMsgPres = true;
15764                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
15765                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
15766                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
15767                         value.choice.RRCContainer);
15768                }
15769
15770                break;
15771             }
15772
15773          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
15774          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
15775             {
15776                if(duUeCb->f1UeDb)
15777                {
15778                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
15779                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
15780                   {
15781                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
15782                                       choice.DRBs_ToBeSetupMod_List;
15783
15784                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
15785                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
15786                      {
15787                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
15788                         ret = RFAILED;
15789                      }
15790                   }
15791
15792                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
15793                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
15794
15795                   {
15796                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
15797                                       choice.DRBs_ToBeModified_List;
15798                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
15799                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
15800                      {
15801                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
15802                         ret = RFAILED;
15803                      }
15804                   }
15805                }
15806                break;
15807             }
15808
15809          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
15810             {
15811                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
15812                if(duUeCb->f1UeDb)
15813                {
15814                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
15815                }
15816                break;
15817             }
15818
15819          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
15820             {
15821                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
15822                   RRCReconfigurationCompleteIndicator_true)
15823                {
15824                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
15825                }
15826                break;
15827             }
15828          case ProtocolIE_ID_id_TransmissionActionIndicator:
15829             {
15830                if(duUeCb->f1UeDb)
15831                {
15832                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
15833                   {
15834                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
15835                   }
15836                   else
15837                   {
15838                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
15839                   }
15840                }
15841                break;
15842             }
15843
15844          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15845             {
15846                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
15847                {
15848                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
15849                }
15850                break;
15851             }
15852
15853       }
15854    }
15855
15856    if(ret != RFAILED)
15857    {
15858       ret = duProcUeContextModReq(duUeCb);
15859    }
15860    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
15861    return ret;
15862 }
15863
15864 /*****************************************************************i
15865 *
15866 * @brief Free memory allocated for UE Context Release Request
15867 *
15868 * @details
15869 *
15870 *    Function : FreeUeContextReleaseReq
15871 *
15872 *    Functionality:
15873 *         - Free memory allocated for UE Context Release Request
15874 *
15875 * @params[in] F1AP_PDU_t *f1apMsg
15876 * @return void
15877 *
15878 * *************************************************************/
15879 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
15880 {
15881    uint8_t ieIdx;
15882    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
15883
15884    if(f1apMsg)
15885    {
15886       if(f1apMsg->choice.initiatingMessage)
15887       {
15888          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
15889          if(ueReleaseReq->protocolIEs.list.array)
15890          {
15891             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
15892             {
15893                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
15894             }
15895             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
15896          }
15897          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
15898       }
15899       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15900    }
15901
15902 }
15903 /*****************************************************************i
15904 *
15905 * @brief Build and Send UE Context Release Request
15906 *
15907 * @details
15908 *
15909 *    Function : BuildAndSendUeContextReleaseReq
15910 *
15911 *    Functionality:
15912 *         - Build and Send UE Context Release Request
15913 *
15914 * @params[in]
15915 * @return ROK     - success
15916 *         RFAILED - failure
15917 *
15918 * *************************************************************/
15919 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
15920 {
15921    bool memAllocFail = false;
15922    uint8_t ieIdx =0;
15923    uint8_t ret = RFAILED;
15924    uint16_t cellIdx =0;
15925    uint16_t crnti = 0;
15926    uint8_t  elementCnt = 0;
15927    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
15928    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
15929    asn_enc_rval_t encRetVal;
15930    F1AP_PDU_t *f1apMsg = NULLP;
15931    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
15932
15933    DU_LOG("\nINFO  --> Building the UE Context Release Request");
15934    do
15935    {
15936       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15937       if(f1apMsg == NULLP)
15938       {
15939          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
15940          break;
15941       }
15942
15943       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
15944       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
15945       if(f1apMsg->choice.initiatingMessage == NULLP)
15946       {
15947          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
15948          initiatingMessage");
15949          break;
15950       }
15951       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
15952       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
15953       f1apMsg->choice.initiatingMessage->value.present = \
15954       InitiatingMessage__value_PR_UEContextReleaseRequest;
15955
15956       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
15957
15958       elementCnt = 2;
15959
15960       ueReleaseReq->protocolIEs.list.count = elementCnt;
15961       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
15962
15963       /* Initialize the F1Setup members */
15964       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
15965       if(ueReleaseReq->protocolIEs.list.array == NULLP)
15966       {
15967          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
15968          break;
15969       }
15970       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
15971       {
15972          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
15973                sizeof(UEContextReleaseRequest_t));
15974          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
15975          {
15976             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
15977             memAllocFail = true;
15978             break;
15979          }
15980       }
15981       if(memAllocFail == true)
15982          break;
15983
15984       /* Fetching Ue Cb Info*/
15985       GET_CELL_IDX(cellId, cellIdx);
15986       if(duCb.actvCellLst[cellIdx] == NULLP)
15987       {
15988          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
15989          break;
15990       }
15991       else
15992       {
15993          GET_CRNTI(crnti, ueId);
15994          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
15995          {
15996             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
15997             break;
15998          }
15999          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
16000          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
16001       }
16002
16003       ieIdx=0;
16004       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16005       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16006       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
16007       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
16008       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16009
16010       ieIdx++;
16011       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16012       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16013       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
16014       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
16015       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16016
16017       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16018
16019       /* Encode the F1SetupRequest type as APER */
16020       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16021       encBufSize = 0;
16022       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16023       /* Encode results */
16024       if(encRetVal.encoded == ENCODE_FAIL)
16025       {
16026          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
16027                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16028          break;
16029       }
16030       else
16031       {
16032          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
16033          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16034          {
16035             printf("%x",encBuf[ieIdx]);
16036          }
16037       }
16038
16039       /* Sending msg */
16040       if(sendF1APMsg() != ROK)
16041       {
16042          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
16043          break;
16044       }
16045       ret = ROK;
16046       break;
16047    }while(true);
16048
16049    FreeUeContextReleaseReq(f1apMsg);
16050    return ret;
16051 }
16052 /*****************************************************************i
16053  *
16054  * @brief Free memory allocated for UE Context Release Complete
16055  *
16056  * @details
16057  *
16058  *    Function : FreeUeContextReleaseComplete
16059  *
16060  *    Functionality:
16061  *         - Free memory allocated for UE Context Release Complete
16062  *
16063  * @params[in] F1AP_PDU_t *f1apMsg
16064  * @return void
16065  *
16066  * *************************************************************/
16067 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
16068 {
16069    uint8_t ieIdx;
16070    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16071
16072    if(f1apMsg)
16073    {
16074       if(f1apMsg->choice.successfulOutcome)
16075       {
16076          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16077          if(ueReleaseComplete->protocolIEs.list.array)
16078          {
16079             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
16080             {
16081                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
16082             }
16083             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
16084          }
16085          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16086       }
16087       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16088    }
16089
16090 }
16091 /*****************************************************************i
16092  *
16093  * @brief Build and Send UE Context Release Complete
16094  *
16095  * @details
16096  *
16097  *    Function : BuildAndSendUeContextReleaseComplete
16098  *
16099  *    Functionality:
16100  *         - Build and Send UE Context Release Complete
16101  *
16102  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
16103  * @return ROK     - success
16104  *         RFAILED - failure
16105  *
16106  * *************************************************************/
16107 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
16108 {
16109    bool memAllocFail = false;
16110    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
16111    asn_enc_rval_t encRetVal;
16112    F1AP_PDU_t *f1apMsg = NULLP;
16113    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16114
16115    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
16116    do
16117    {
16118       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16119       if(f1apMsg == NULLP)
16120       {
16121          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
16122          break;
16123       }
16124
16125       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
16126       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16127       if(f1apMsg->choice.successfulOutcome == NULLP)
16128       {
16129          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
16130                successfulOutcome");
16131          break;
16132       }
16133       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
16134       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
16135       f1apMsg->choice.successfulOutcome->value.present = \
16136       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
16137
16138       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16139
16140       elementCnt = 2;
16141       ueReleaseComplete->protocolIEs.list.count = elementCnt;
16142       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
16143
16144       /* Initialize the UE Release Complete members */
16145       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
16146       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
16147       {
16148          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
16149          break;
16150       }
16151       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16152       {
16153          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
16154                sizeof(UEContextReleaseComplete_t));
16155          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
16156          {
16157             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
16158             elements");
16159             memAllocFail = true;
16160             break;
16161          }
16162       }
16163       if(memAllocFail == true)
16164          break;
16165
16166
16167       ieIdx=0;
16168       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16169       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16170       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
16171       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
16172       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16173
16174       ieIdx++;
16175       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16176       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16177       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
16178       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
16179       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16180
16181       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16182
16183       /* Encode the F1SetupComplete type as APER */
16184       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16185       encBufSize = 0;
16186       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16187       /* Encode results */
16188       if(encRetVal.encoded == ENCODE_FAIL)
16189       {
16190          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
16191                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16192          break;
16193       }
16194       else
16195       {
16196          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
16197          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16198          {
16199             printf("%x",encBuf[ieIdx]);
16200          }
16201       }
16202
16203       /* Sending msg */
16204       if(sendF1APMsg() != ROK)
16205       {
16206          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
16207          break;
16208       }
16209       ret = ROK;
16210       break;
16211    }while(true);
16212
16213    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
16214          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
16215    {
16216       ret = duSendCellDeletReq(cellId);
16217       if(ret != ROK)
16218       {
16219          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
16220                Delete req for CellId");
16221       }
16222    }
16223    FreeUeContextReleaseComplete(f1apMsg);
16224    return ret;
16225
16226 }
16227
16228 /*******************************************************************
16229 *
16230 * @brief added free part for the memory allocated by aper_decoder
16231 *
16232 * @details
16233 *
16234 *    Function : freeAperDecodeUeContextReleaseCommand
16235 *
16236 *    Functionality: added free part for the memory allocated by aper_decoder
16237 *
16238 * @params[in] F1AP_PDU_t *f1apMsg
16239 * @return void
16240 *
16241 * ****************************************************************/
16242 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16243 {
16244    uint8_t ieIdx=0;
16245    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16246
16247    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16248
16249    if(ueContextReleaseCommand->protocolIEs.list.array)
16250    {
16251       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16252       {
16253          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16254          {
16255             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16256             {
16257                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16258                   break;
16259                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16260                   break;
16261                case ProtocolIE_ID_id_Cause:
16262                   break;
16263                case ProtocolIE_ID_id_RRCContainer:
16264                {
16265                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
16266                   {
16267                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
16268                   }
16269                   break;
16270                }
16271                default :
16272                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16273                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16274                   break;
16275             }
16276          }
16277          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
16278       }
16279       free(ueContextReleaseCommand->protocolIEs.list.array);
16280    }
16281 }
16282 /*******************************************************************
16283 *
16284 * @brief processing of UE Context Release Command
16285 *
16286 * @details
16287 *
16288 *    Function : procF1UeContextReleaseCommand
16289 *
16290 *    Functionality: processing of UE Context Release Command
16291 *
16292 * @params[in] F1AP_PDU_t *f1apMsg
16293 * @return void
16294 *
16295 * ****************************************************************/
16296 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16297 {
16298    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
16299    uint16_t cellIdx =0, cellId = 0;
16300    bool ueIdxFound = false;
16301    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
16302    DuUeCb   *duUeCb = NULLP;
16303    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16304
16305    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16306
16307    if(ueContextReleaseCommand->protocolIEs.list.array)
16308    {
16309       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16310       {
16311          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16312          {
16313             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16314             {
16315                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16316                   {
16317                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16318                                     value.choice.GNB_CU_UE_F1AP_ID;
16319                      break;
16320                   }
16321
16322                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16323                   {
16324                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16325                                      value.choice.GNB_DU_UE_F1AP_ID;
16326                      break;
16327                   }
16328
16329                case ProtocolIE_ID_id_Cause:
16330                   {
16331                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16332                      {
16333                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
16334                         {
16335                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16336                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
16337                            {
16338                               cellId = duCb.actvCellLst[cellIdx]->cellId;
16339                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
16340                               ueIdxFound = true;
16341                               break;
16342                            }
16343                         }
16344                         if(ueIdxFound == true)
16345                         {
16346                            break;
16347                         }
16348                      }
16349
16350                      if(!ueIdxFound)
16351                      {
16352                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
16353                         ret = RFAILED;
16354                      }
16355                      break;
16356                   }
16357
16358                case ProtocolIE_ID_id_RRCContainer:
16359                   {
16360                      if(ueIdxFound == true)
16361                      {
16362                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16363                         if(duUeCb->f1UeDb)
16364                         {
16365                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
16366                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
16367                            duUeCb->f1UeDb->cellIdx = cellIdx;
16368                            /* Filling Dl RRC Msg Info */
16369                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16370                            if(!duUeCb->f1UeDb->dlRrcMsg)
16371                            {
16372                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16373                                     Memory allocation failed ");
16374                               ret = RFAILED;
16375                            }
16376                            else
16377                            {
16378                               duUeCb->f1UeDb->dlRrcMsgPres = true;
16379                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16380                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16381                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16382                                     value.choice.RRCContainer);
16383                            }
16384
16385                         }
16386                         else
16387                         {
16388                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16389                                  Memory allocation failed ");
16390                            ret = RFAILED;
16391
16392                         }
16393                      }
16394                      break;
16395                   }
16396                default :
16397                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16398                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16399                   break;
16400             }
16401          }
16402       }
16403    }
16404    if(ret != RFAILED)
16405    {
16406       duProcUeContextReleaseCommand(cellId, duUeCb);
16407    }
16408    freeAperDecodeUeContextReleaseCommand(f1apMsg);
16409    return ret;
16410 }
16411
16412 /**************************************************************
16413  *
16414  * @brief free the memory allocated by aper decoder for paging
16415  *
16416  * @details
16417  *
16418  *    Function : freeAperDecodePagingMsg
16419  *
16420  *    Functionality:
16421  *         - free the memory allocated by aper decoder for
16422  *         the paging f1ap msg
16423  *
16424  * @params[in] Paging_t   *paging
16425  * @return ROK     - success
16426  *         RFAILED - failure
16427  *
16428  ****************************************************************/
16429 void freeAperDecodePagingMsg(Paging_t   *paging)
16430 {
16431    uint8_t ieIdx, cellIdx;
16432    PagingCell_ItemIEs_t *pagingCellItemIes;
16433    PagingCell_Item_t *pagingCellItem;
16434    PagingCell_list_t  *pagingCelllist;
16435
16436    if(paging)
16437    {
16438       if(paging->protocolIEs.list.array)
16439       {
16440          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
16441          {
16442             if(paging->protocolIEs.list.array[ieIdx])
16443             {
16444                switch(paging->protocolIEs.list.array[ieIdx]->id)
16445                {
16446                   case ProtocolIE_ID_id_UEIdentityIndexValue:
16447                      {
16448                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
16449                         break;
16450                      }
16451                   case ProtocolIE_ID_id_PagingIdentity:
16452                      {
16453                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
16454                         {
16455                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
16456                            {
16457                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
16458                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
16459                               {
16460                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
16461                               }
16462                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
16463                            }
16464                         }
16465                         break;
16466                      }
16467                   case ProtocolIE_ID_id_PagingCell_List:
16468                      {
16469                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
16470                         if(pagingCelllist->list.array)
16471                         {
16472                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
16473                            {
16474                               if(pagingCelllist->list.array[cellIdx])
16475                               {
16476                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
16477                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
16478                                  {
16479                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
16480                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
16481                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
16482                                  }
16483                                  free(pagingCelllist->list.array[cellIdx]);
16484                               }
16485                            }
16486                            free(pagingCelllist->list.array);
16487                         }
16488                         break;
16489                      }
16490                }
16491                free(paging->protocolIEs.list.array[ieIdx]);
16492             }
16493          }
16494          free(paging->protocolIEs.list.array);
16495
16496       }
16497    }
16498 }
16499
16500 /**************************************************************
16501  *
16502  * @brief processing the paging f1ap msg received from CU
16503  *
16504  * @details
16505  *
16506  *    Function : procPagingMsg
16507  *
16508  *    Functionality:
16509  *         - processing the paging f1ap msg received from CU
16510  *
16511  * @params[in] F1AP_PDU_t *f1apMsg
16512  * @return ROK     - success
16513  *         RFAILED - failure
16514  *
16515  *
16516  ****************************************************************/
16517 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
16518 {
16519    uint8_t ieIdx = 0, cellListIdx = 0;
16520    uint16_t cellId = 0;
16521    Paging_t   *paging = NULLP;
16522    PagingCell_list_t  *pagingCelllist = NULLP;
16523    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
16524    PagingCell_Item_t *pagingCellItem = NULLP;
16525    DuPagingMsg *tmpPagingParam = NULLP;
16526
16527    DU_LOG("\nINFO  --> DU APP : Processing the Paging Message");
16528    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
16529    if(paging)
16530    {
16531       if(paging->protocolIEs.list.array)
16532       {
16533          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
16534          if(tmpPagingParam == NULLP)
16535          {
16536             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
16537             freeAperDecodePagingMsg(paging);
16538             return RFAILED;
16539          }
16540          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
16541          {
16542             if(paging->protocolIEs.list.array[ieIdx])
16543             {
16544                switch(paging->protocolIEs.list.array[ieIdx]->id)
16545                {
16546                   case ProtocolIE_ID_id_UEIdentityIndexValue:
16547                      {
16548                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
16549                                          &tmpPagingParam->pagUeId);
16550                         break;
16551                      }
16552
16553                   case ProtocolIE_ID_id_PagingIdentity:
16554                      {
16555                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
16556                         {
16557                            case PagingIdentity_PR_cNUEPagingIdentity:
16558                               {
16559                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
16560                                  {
16561                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
16562                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
16563
16564                                  }
16565                                  break;
16566                               }
16567                             case PagingIdentity_PR_rANUEPagingIdentity:
16568                                {
16569                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
16570                                   break;
16571                                }
16572                             default:
16573                                {
16574                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
16575                                   continue;
16576                                }
16577                         }
16578                      }
16579
16580                   case ProtocolIE_ID_id_PagingDRX:
16581                      {
16582                         tmpPagingParam->pagingDrxPres = TRUE;
16583                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
16584                         break;
16585                      }
16586
16587                   case ProtocolIE_ID_id_PagingPriority:
16588                      {
16589                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
16590                         break;
16591                      }
16592
16593                   case ProtocolIE_ID_id_PagingCell_List:
16594                      {
16595                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
16596                         if(pagingCelllist->list.array)
16597                         {
16598                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
16599                            {
16600                               if(pagingCelllist->list.array[cellListIdx])
16601                               {
16602                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
16603                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
16604                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
16605                                  if(processPagingMsg(cellId, tmpPagingParam) != ROK)
16606                                  {
16607                                     DU_LOG("\nERROR  --> DU APP : Paging Processing Failed at CellId:%d",cellId);
16608                                     continue;
16609                                  }
16610                               }
16611                            }
16612                         }
16613                         break;
16614                      }
16615                    default:
16616                      {
16617                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
16618                          break;
16619                      }
16620                }
16621             }
16622          }
16623       }
16624    }
16625    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
16626    freeAperDecodePagingMsg(paging);
16627
16628    return ROK;
16629 }
16630
16631 /**************************************************************
16632  *
16633  * @brief Handles received F1AP message and sends back response
16634  *
16635  * @details
16636  *
16637  *    Function : F1APMsgHdlr
16638  *
16639  *    Functionality:
16640  *         - Decodes received F1AP control message
16641  *         - Prepares response message, encodes and sends to SCTP
16642  *
16643  * @params[in]
16644  * @return ROK     - success
16645  *         RFAILED - failure
16646  *
16647  * ****************************************************************/
16648 void F1APMsgHdlr(Buffer *mBuf)
16649 {
16650    int i =0;
16651    char *recvBuf =NULLP;
16652    MsgLen copyCnt =0;
16653    MsgLen recvBufLen =0;
16654    F1AP_PDU_t *f1apMsg =NULLP;
16655    asn_dec_rval_t rval; /* Decoder return value */
16656    F1AP_PDU_t f1apasnmsg ;
16657    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
16658    ODU_PRINT_MSG(mBuf, 0,0);
16659
16660    /* Copy mBuf into char array to decode it */
16661    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
16662    DU_ALLOC(recvBuf, (Size)recvBufLen);
16663
16664    if(recvBuf == NULLP)
16665    {
16666       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
16667       return;
16668    }
16669    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
16670    {
16671       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
16672       return;
16673    }
16674
16675    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
16676    for(i=0; i< recvBufLen; i++)
16677    {
16678       printf("%x",recvBuf[i]);
16679    }
16680
16681    /* Decoding flat buffer into F1AP messsage */
16682    f1apMsg = &f1apasnmsg;
16683    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
16684
16685    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
16686
16687    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
16688    {
16689       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
16690       return;
16691    }
16692    printf("\n");
16693    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16694
16695    switch(f1apMsg->present)
16696    {
16697       case F1AP_PDU_PR_successfulOutcome:
16698          {
16699             switch(f1apMsg->choice.successfulOutcome->value.present)
16700             {
16701                case SuccessfulOutcome__value_PR_ResetAcknowledge:
16702                   {
16703                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
16704                      break;
16705                   }
16706                case SuccessfulOutcome__value_PR_F1SetupResponse:
16707                   {
16708 #ifndef ODU_TEST_STUB
16709                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
16710 #endif
16711                      break;
16712                   }
16713
16714                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
16715                   {
16716                      procF1GNBDUCfgUpdAck(f1apMsg);
16717                      break;
16718                   }
16719
16720                default:
16721                   {
16722                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
16723                            f1apMsg->choice.successfulOutcome->value.present);
16724                      return;
16725                   }
16726             }/* End of switch(successfulOutcome) */
16727             free(f1apMsg->choice.successfulOutcome);
16728             break;
16729          }
16730       case F1AP_PDU_PR_initiatingMessage:
16731          {
16732             switch(f1apMsg->choice.initiatingMessage->value.present)
16733             {
16734                case InitiatingMessage__value_PR_Reset:
16735                   {
16736                      procF1ResetReq(f1apMsg);
16737                      break;
16738                   }
16739                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
16740                   {
16741                      procF1DlRrcMsgTrans(f1apMsg);
16742                      break;
16743                   }
16744                case InitiatingMessage__value_PR_UEContextSetupRequest:
16745                   {
16746                      procF1UeContextSetupReq(f1apMsg);
16747                      break;
16748                   }
16749                case InitiatingMessage__value_PR_UEContextModificationRequest:
16750                   {
16751                      procF1UeContextModificationReq(f1apMsg);
16752                      break;
16753                   }
16754                case InitiatingMessage__value_PR_UEContextReleaseCommand:
16755                   {
16756                       procF1UeContextReleaseCommand(f1apMsg);
16757                       break;
16758                   }
16759                case InitiatingMessage__value_PR_Paging:
16760                   {
16761                      procPagingMsg(f1apMsg);
16762                      break;
16763                   }
16764                default:
16765                   {
16766                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
16767                            f1apMsg->choice.initiatingMessage->value.present);
16768                      return;
16769                   }
16770             }/* End of switch(initiatingMessage) */
16771             free(f1apMsg->choice.initiatingMessage);
16772             break;
16773          }
16774
16775       default:
16776          {
16777             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
16778             return;
16779          }
16780          free(f1apMsg);
16781
16782    }/* End of switch(f1apMsg->present) */
16783
16784    DU_FREE(recvBuf, (Size)recvBufLen);
16785 } /* End of F1APMsgHdlr */
16786
16787 /**********************************************************************
16788   End of file
16789  **********************************************************************/