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_sys_info_hdl.h"
 114 #include "du_e2ap_msg_hdl.h"
 115 #include "du_f1ap_conversions.h"
 116
 117 #ifdef O1_ENABLE
 118 #include "CmInterface.h"
 119 extern StartupConfig g_cfg;
 120 #endif
 121
 122 DuCfgParams duCfgParam;
 123
 124 /******************************************************************
 125  *
 126  * @brief Function to fetch lcId based on DRB Id
 127  *
 128  * @details
 129  *
 130  *    Function : fetchLcId
 131  *
 132  *    @params[in] drbId
 133  *
 134  *    Functionality: Function to fetch lcId based on DRB Id
 135  *
 136  * Returns: lcId - SUCCESS
 137  *          RFAILED - FAILURE
 138  *****************************************************************/
 139
 140 uint8_t fetchLcId(uint8_t drbId)
 141 {
 142    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 143
 144    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 145    {
 146       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 147       {
 148          if(duCb.actvCellLst[cellIdx] != NULLP)
 149          {
 150             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 151             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 152             {
 153                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 154                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 155                {
 156                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 157                   return lcId;
 158                }
 159             }
 160          }
 161       }
 162    }
 163    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 164    return RFAILED;
 165 }
 166
 167 /*******************************************************************
 168 *
 169 * @brief Adding F1AP pdu to reserved pdu list
 170 *
 171 * @details
 172 *
 173 *    Function : addToReservedF1apPduList
 174 *
 175 *    Functionality: Adding F1AP pdu to reserved pdu list.
 176 *     These pdu are awaiting aknowledgment from CU
 177 *
 178 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 179 *
 180 * @return ROK - success
 181 *         RFAILED - failure
 182 *
 183 * ****************************************************************/
 184 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 185 {
 186    CmLList         *node = NULLP;
 187    ReservedF1apPduInfo *pduInfo = NULLP;
 188    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 189    if(pduInfo)
 190    {
 191       DU_ALLOC(node, sizeof(CmLList));
 192       if(node)
 193       {
 194          pduInfo->transId = transId;
 195          pduInfo->f1apMsg = (void*) f1apPdu;
 196
 197          node->node = (PTR)pduInfo;
 198          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 199       }
 200    }
 201 }
 202
 203 /*******************************************************************
 204 *
 205 * @brief searching for F1AP pdu from ReservedF1apPduList
 206 *
 207 * @details
 208 *
 209 *    Function : searchFromReservedF1apPduList
 210 *
 211 *    Functionality: searching for F1AP pdu information
 212 *
 213 * @params[in] uint8_t transId
 214 *
 215 * @return pointer to F1AP_PDU_t
 216 *
 217 * ****************************************************************/
 218
 219 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 220 {
 221    CmLList         *node;
 222    ReservedF1apPduInfo *f1apPdu;
 223    if(duCb.reservedF1apPduList.count)
 224    {
 225       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 226       while(node)
 227       {
 228          f1apPdu = (ReservedF1apPduInfo*)node->node;
 229          if(f1apPdu->transId == transId)
 230          {
 231             return node;
 232          }
 233          node = node->next;
 234       }
 235    }
 236    return NULL;
 237 }
 238
 239 /*******************************************************************
 240 *
 241 * @brief deleting F1AP pdu information from ReservedF1apPduList
 242 *
 243 * @details
 244 *
 245 *    Function : deleteFromReservedF1apPduList
 246 *
 247 *    Functionality: deleting pdu information from ReservedF1apPduList
 248 *
 249 * @params[in] CmLList *node
 250 *
 251 * @return void
 252 *
 253 * ****************************************************************/
 254
 255 void deleteFromReservedF1apPduList(CmLList *node)
 256 {
 257    ReservedF1apPduInfo *f1apPdu;
 258
 259    if(node != NULL)
 260    {
 261       f1apPdu = (ReservedF1apPduInfo *)node->node;
 262       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 263       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 264       DU_FREE(node, sizeof(CmLList));
 265       node = NULL;
 266    }
 267 }
 268
 269 /*******************************************************************
 270  *
 271  * @brief Builds Uplink Info for NR
 272  *
 273  * @details
 274  *
 275  *    Function : BuildULNRInfo
 276  *
 277  *    Functionality: Building NR Uplink Info
 278  *
 279  * @params[in] NRFreqInfo_t *ulnrfreq
 280  * @return ROK     - success
 281  *         RFAILED - failure
 282  *
 283  * ****************************************************************/
 284 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 285 {
 286    uint8_t idx=0;
 287    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 288                        fdd.ulNrFreqInfo.nrArfcn;
 289    ulnrfreq->freqBandListNr.list.count = 1;
 290    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 291    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 292    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 293    {
 294       return RFAILED;
 295    }
 296    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 297    {
 298       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 299       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 300       {
 301          return RFAILED;
 302       }
 303    }
 304    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 305                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 306                                                                  freqBand[0].nrFreqBand;
 307    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 308    return ROK;
 309 }
 310 /*******************************************************************
 311  *
 312  * @brief Builds Downlink NR Info
 313  *
 314  * @details
 315  *
 316  *    Function : BuildDLNRInfo
 317  *
 318  *    Functionality: Building Downlink NR Info
 319  *
 320  * @params[in] NRFreqInfo_t *dlnrfreq
 321  * @return ROK     - success
 322  *         RFAILED - failure
 323  *
 324  * ****************************************************************/
 325 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 326 {
 327    uint8_t idx=0;
 328    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 329                        fdd.dlNrFreqInfo.nrArfcn;
 330    dlnrfreq->freqBandListNr.list.count = 1;
 331    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 332    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 333    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 334    {
 335       return RFAILED;
 336    }
 337    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 338    {
 339       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 340       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 341       {
 342          return RFAILED;
 343       }
 344    }
 345    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 346                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 347                                                                  freqBand[0].nrFreqBand;
 348    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 349
 350    return ROK;
 351 }
 352
 353 /*******************************************************************
 354  *
 355  * @brief Builds NRCell ID
 356  *
 357  * @details
 358  *
 359  *    Function : BuildNrCellId
 360  *
 361  *    Functionality: Building the NR Cell ID
 362  *
 363  * @params[in] BIT_STRING_t *nrcell
 364  * @return ROK     - success
 365  *         RFAILED - failure
 366  *
 367  * ****************************************************************/
 368
 369 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 370 {
 371    memset(nrcell->buf, 0, nrcell->size);
 372    nrcell->buf[4]   = duCfgParam.sib1Params.cellIdentity;
 373    nrcell->bits_unused = 4;
 374    return ROK;
 375 }
 376
 377 /*******************************************************************
 378  *
 379  * @brief Builds Nrcgi
 380  *
 381  * @details
 382  *
 383  *    Function : BuildNrcgi
 384  *
 385  *    Functionality: Building the PLMN ID and NR Cell id
 386  *
 387  * @params[in] NRCGI_t *nrcgi
 388  * @return ROK     - success
 389  *         RFAILED - failure
 390  *
 391  * ****************************************************************/
 392 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 393 {
 394    uint8_t ret;
 395    uint8_t byteSize = 5;
 396    /* Allocate Buffer Memory */
 397    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 398    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 399    if(nrcgi->pLMN_Identity.buf == NULLP)
 400    {
 401       return RFAILED;
 402    }
 403    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 404          nrcgi->pLMN_Identity.buf); // Building PLMN function
 405    if(ret != ROK)
 406    {
 407       return RFAILED;
 408    }
 409    /*nrCellIdentity*/
 410    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 411    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 412    if(nrcgi->nRCellIdentity.buf == NULLP)
 413    {
 414       return RFAILED;
 415    }
 416    BuildNrCellId(&nrcgi->nRCellIdentity);
 417
 418    return ROK;
 419 }
 420 /*******************************************************************
 421  *
 422  * @brief Builds FiveGStac
 423  *
 424  * @details
 425  *
 426  *    Function : BuildFiveGSTac
 427  *
 428  *    Functionality: Building the FiveGSTac
 429  *
 430  * @params[in] OCTET_STRING_t *fivegsTac
 431  * @return ROK     - success
 432  *         RFAILED - failure
 433  *
 434  * ****************************************************************/
 435 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 436 {
 437    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 438    if(servcell->fiveGS_TAC == NULLP)
 439    {
 440       return RFAILED;
 441    }
 442    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 443    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 444          sizeof(servcell->fiveGS_TAC->size));
 445    if(servcell->fiveGS_TAC->buf == NULLP)
 446    {
 447       return RFAILED;
 448    }
 449    servcell->fiveGS_TAC->buf[0] = 0;
 450    servcell->fiveGS_TAC->buf[1] = 0;
 451    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 452    return ROK;
 453 }
 454
 455 /*******************************************************************
 456  *
 457  * @brief fill nr frequency information
 458  *
 459  * @details
 460  *
 461  *    Function : fillNrTddInfo
 462  *
 463  *    Functionality: fill nr frequency information
 464  *
 465  * @params[in] NRFreqInfo_t freqInfo
 466  * @return ROK     - success
 467  *         RFAILED - failure
 468  *
 469  * ****************************************************************/
 470 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 471 {
 472    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 473    NRFreqInfo_t *freqInfo = NULLP;
 474
 475    if(tddInfo == NULLP)
 476    {
 477       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 478       return RFAILED;
 479    }
 480
 481    freqInfo = &tddInfo->nRFreqInfo;
 482    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 483
 484    freqInfo->freqBandListNr.list.count = elementCnt;
 485    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 486    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 487    if(!freqInfo->freqBandListNr.list.array)
 488    {
 489       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 490       return RFAILED;
 491    }
 492
 493    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 494    {
 495       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 496       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 497       {
 498          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 499          return RFAILED;
 500       }
 501
 502       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 503       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 504       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 505       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 506       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 507
 508       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 509             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 510       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 511       {
 512          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 513          return RFAILED;
 514       }
 515
 516       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 517       {
 518          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 519                sizeof(SupportedSULFreqBandItem_t));
 520          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 521          {
 522             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 523             return RFAILED;
 524          }
 525
 526          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 527          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 528       }
 529    }
 530
 531    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 532    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 533
 534    return ROK;
 535 }
 536
 537 /*******************************************************************
 538  *
 539  * @brief Builds NR Mode
 540  *
 541  * @details
 542  *
 543  *    Function : BuildNrMode
 544  *
 545  *    Functionality: Building the NR Mode
 546  *
 547  * @params[in] NR_Mode_Info_t *fdd
 548  * @return ROK     - success
 549  *         RFAILED - failure
 550  *
 551  * ****************************************************************/
 552 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 553 {
 554    uint8_t BuildDLNRInforet=0;
 555    uint8_t BuildULNRInforet=0;
 556
 557 #ifdef NR_TDD
 558    mode->present = NR_Mode_Info_PR_tDD;
 559 #else
 560    mode->present = NR_Mode_Info_PR_fDD;
 561 #endif
 562
 563    if(mode->present == NR_Mode_Info_PR_fDD)
 564    {
 565       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 566       if(mode->choice.fDD == NULLP)
 567       {
 568          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 569          return RFAILED;
 570       }
 571       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 572       if(BuildULNRInforet != ROK)
 573       {
 574          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 575          return RFAILED;
 576       }
 577       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 578       if(BuildDLNRInforet != ROK)
 579       {
 580          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 581          return RFAILED;
 582       }
 583       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 584                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 585                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 586       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 587                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 588                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 589       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 590                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 591                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 592       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 593                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 594                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 595    }
 596    else if(mode->present == NR_Mode_Info_PR_tDD)
 597    {
 598       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 599       if(mode->choice.tDD == NULLP)
 600       {
 601          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 602          return RFAILED;
 603       }
 604
 605       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 606       {
 607          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 608          return RFAILED;
 609       }
 610
 611    }
 612
 613    return ROK;
 614 }
 615 /*******************************************************************
 616  *
 617  * @brief Builds IE Extensions for Served PLMNs
 618  *
 619  * @details
 620  *
 621  *    Function : BuildExtensions
 622  *
 623  *    Functionality: Building the IE Extensions
 624  *
 625  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 626  * @return ROK     - success
 627  *         RFAILED - failure
 628  *
 629  * ****************************************************************/
 630 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 631 {
 632    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 633    uint8_t elementCnt=0, extensionCnt=0;
 634
 635    extensionCnt=IE_EXTENSION_LIST_COUNT;
 636    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 637    if((*ieExtend) == NULLP)
 638    {
 639       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 640       return RFAILED;
 641    }
 642    (*ieExtend)->list.count = extensionCnt;
 643    (*ieExtend)->list.size = \
 644                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 645    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 646    if((*ieExtend)->list.array == NULLP)
 647    {
 648       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 649       return RFAILED;
 650    }
 651    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 652    {
 653       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 654             sizeof(ServedPLMNs_ItemExtIEs_t));
 655       if((*ieExtend)->list.array[plmnidx] == NULLP)
 656       {
 657          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 658          return RFAILED;
 659       }
 660    }
 661
 662    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 663    idx = 0;
 664    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 665    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 666    (*ieExtend)->list.array[idx]->extensionValue.present = \
 667    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 668    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 669       list.count = elementCnt;
 670    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 671       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 672       list.count * sizeof(SliceSupportItem_t *);
 673
 674    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 675          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 676    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 677          list.array == NULLP)
 678    {
 679       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 680       return RFAILED;
 681    }
 682
 683    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 684    {
 685       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 686             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 687       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 688             list.array[sliceLstIdx] == 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.size = sizeof(uint8_t);
 695       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 696             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 697             extensionValue.choice.SliceSupportList.\
 698             list.array[sliceLstIdx]->sNSSAI.sST.size);
 699       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 700             .list.array[sliceLstIdx]->sNSSAI.sST.buf == 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.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 707          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 708
 709       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 710             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 711       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 712             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 713       {
 714          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 715          return RFAILED;
 716       }
 717       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 718          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 719       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 720             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 721             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 722       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 723             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 724       {
 725          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 726          return RFAILED;
 727       }
 728       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 729       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 730       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 731       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 732    }
 733    return ROK;
 734 }
 735 /*******************************************************************
 736  *
 737  * @brief Builds Served PLMN
 738  *
 739  * @details
 740  *
 741  *    Function : BuildServedPlmn
 742  *
 743  *    Functionality: Building the Served PLMN
 744  *
 745  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 746  * @return ROK     - success
 747  *         RFAILED - failure
 748  *
 749  * ****************************************************************/
 750 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 751 {
 752    uint8_t  plmnidx;
 753    uint8_t  servPlmnCnt=1;
 754    uint8_t buildPlmnIdret=0;
 755    uint8_t BuildExtensionsret=0;
 756    srvplmn->list.count = servPlmnCnt;
 757    srvplmn->list.size = \
 758                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 759    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 760    if(srvplmn->list.array == NULLP)
 761    {
 762       return RFAILED;
 763    }
 764    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 765    {
 766       DU_ALLOC(srvplmn->list.array[plmnidx],\
 767             sizeof(ServedPLMNs_Item_t));
 768       if(srvplmn->list.array[plmnidx] == NULLP)
 769       {
 770          return RFAILED;
 771       }
 772    }
 773    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 774    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 775    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 776          srvplmn->list.array[0]->pLMN_Identity.buf);
 777    if(buildPlmnIdret!= ROK)
 778    {
 779       return RFAILED;
 780    }
 781    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 782    if(BuildExtensionsret!= ROK)
 783    {
 784       return RFAILED;
 785    }
 786    return ROK;
 787 }
 788 /*******************************************************************
 789  *
 790  * @brief Builds Served Cell List
 791  *
 792  * @details
 793  *
 794  *    Function : BuildServedCellList
 795  *
 796  *    Functionality: Building Served Cell List
 797  *
 798  * @params[in] PLMNID plmn
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 805 {
 806    uint8_t  BuildNrcgiret=0;
 807    uint8_t  BuildFiveGSTacret=0;
 808    uint8_t  BuildServedPlmnret=0;
 809    uint8_t  BuildNrModeret=0;
 810    uint8_t  idx;
 811    uint8_t  plmnidx;
 812    uint8_t  plmnCnt=1;
 813    GNB_DU_Served_Cells_Item_t *srvCellItem;
 814    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 815    duServedCell->list.count = plmnCnt;
 816
 817    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 818    if(duServedCell->list.array == NULLP)
 819    {
 820       return RFAILED;
 821    }
 822    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 823    {
 824       DU_ALLOC(duServedCell->list.array[plmnidx],\
 825             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 826       if(duServedCell->list.array[plmnidx] == NULLP)
 827       {
 828          return RFAILED;
 829       }
 830    }
 831    idx = 0;
 832    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 833    duServedCell->list.array[idx]->criticality = Criticality_reject;
 834    duServedCell->list.array[idx]->value.present = \
 835                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 836    srvCellItem = \
 837                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 838    /*nRCGI*/
 839    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 840    if(BuildNrcgiret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nRPCI*/
 845    srvCellItem->served_Cell_Information.nRPCI = \
 846                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 847
 848    /*fiveGS_TAC*/
 849    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 850    if(BuildFiveGSTacret != ROK)
 851    {
 852       return RFAILED;
 853    }
 854    /*Served PLMNs*/
 855    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 856    if(BuildServedPlmnret !=ROK)
 857    {
 858       return RFAILED;
 859    }
 860    /*nR Mode Info with FDD*/
 861    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 862    if(BuildNrModeret != ROK)
 863    {
 864       return RFAILED;
 865    }
 866    /*Measurement timing Config*/
 867    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 868       size = sizeof(uint8_t);
 869    DU_ALLOC(srvCellItem->served_Cell_Information.\
 870          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 871    if(srvCellItem->served_Cell_Information.\
 872          measurementTimingConfiguration.buf == NULLP)
 873    {
 874       return RFAILED;
 875    }
 876    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 877                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 878
 879    /* GNB DU System Information */
 880    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 881          sizeof(GNB_DU_System_Information_t));
 882    if(!srvCellItem->gNB_DU_System_Information)
 883    {
 884       return RFAILED;
 885    }
 886    /* MIB */
 887    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
 888    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 889          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 890    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 891    {
 892       return RFAILED;
 893    }
 894    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
 895                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
 896
 897    /* SIB1 */
 898    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 899                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 900
 901    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 902          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 903    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 904    {
 905       return RFAILED;
 906    }
 907    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 908    {
 909       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 910                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 911    }
 912    return ROK;
 913 }
 914 /*******************************************************************
 915  *
 916  * @brief Builds RRC Version
 917  *
 918  * @details
 919  *
 920  *    Function : BuildRrcVer
 921  *
 922  *    Functionality: Building RRC Version
 923  *
 924  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 925  * @return ROK     - success
 926  *         RFAILED - failure
 927  *
 928  * ****************************************************************/
 929 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 930 {
 931    uint8_t rrcExt;
 932    uint8_t rrcLatest;
 933    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 934    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 935    if(rrcVer->latest_RRC_Version.buf == NULLP)
 936    {
 937       return RFAILED;
 938    }
 939    rrcVer->latest_RRC_Version.buf[0] = 0;
 940    rrcVer->latest_RRC_Version.bits_unused = 5;
 941    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 942    if(rrcVer->iE_Extensions == NULLP)
 943    {
 944       return RFAILED;
 945    }
 946    rrcVer->iE_Extensions->list.count = 1;
 947    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 948    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 949    if(rrcVer->iE_Extensions->list.array == NULLP)
 950    {
 951       return RFAILED;
 952    }
 953    rrcExt = 0;
 954    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 955          sizeof(RRC_Version_ExtIEs_t));
 956    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 957    {
 958       return RFAILED;
 959    }
 960    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 961                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 962    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 963    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 964                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 965    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 966       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 967    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 968          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 969          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 970    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 971          .Latest_RRC_Version_Enhanced.buf == NULLP)
 972    {
 973       return RFAILED;
 974    }
 975    rrcLatest = 0;
 976    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 977       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 978    rrcLatest++;
 979    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 980       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 981    rrcLatest++;
 982    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 983       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 984    return ROK;
 985 }
 986 /*******************************************************************
 987  *
 988  * @brief Sends F1 msg over SCTP
 989  *
 990  * @details
 991  *
 992  *    Function : sendF1APMsg
 993  *
 994  *    Functionality: Sends F1 msg over SCTP
 995  *
 996  * @params[in] Region region
 997  *             Pool pool
 998  * @return ROK     - success
 999  *         RFAILED - failure
1000  *
1001  * ****************************************************************/
1002 uint8_t sendF1APMsg()
1003 {
1004    Buffer *mBuf = NULLP;
1005
1006    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1007    {
1008       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1009       {
1010             ODU_PRINT_MSG(mBuf, 0,0);
1011
1012             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1013             {
1014                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1015                ODU_PUT_MSG_BUF(mBuf);
1016                return RFAILED;
1017             }
1018       }
1019       else
1020       {
1021          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1022          ODU_PUT_MSG_BUF(mBuf);
1023          return RFAILED;
1024       }
1025       ODU_PUT_MSG_BUF(mBuf);
1026    }
1027    else
1028    {
1029       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1030       return RFAILED;
1031    }
1032    return ROK;
1033 } /* sendF1APMsg */
1034
1035 /*******************************************************************
1036  *
1037  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1038  *
1039  * @details
1040  *
1041  *    Function :  FreeRrcVer
1042  *
1043  *    Functionality: deallocating the memory of function BuildRrcVer
1044  *
1045  * @params[in] RRC_Version_t *rrcVer
1046  *
1047  * @return void
1048  *
1049  *****************************************************************/
1050 void FreeRrcVer(RRC_Version_t *rrcVer)
1051 {
1052    if(rrcVer->latest_RRC_Version.buf != NULLP)
1053    {
1054       if(rrcVer->iE_Extensions != NULLP)
1055       {
1056          if(rrcVer->iE_Extensions->list.array != NULLP)
1057          {
1058             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1059             {
1060                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1061                      != NULLP)
1062                {
1063                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1064                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1065                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1066                }
1067                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1068             }
1069             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1070          }
1071          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1072       }
1073       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1074    }
1075 }
1076
1077 /*******************************************************************
1078  *
1079  * @brief Deallocating memory of TDD NrFreqInfo
1080  *
1081  * @details
1082  *
1083  *    Function : freeTddNrFreqInfo
1084  *
1085  *    Functionality: freeTddNrFreqInfo
1086  *
1087  * @params[in]  F1AP_PDU_t *f1apDuCfg
1088  *
1089  * @return ROK     - void
1090  *
1091  * ****************************************************************/
1092 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1093 {
1094    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1095
1096    if(freqInfo->freqBandListNr.list.array)
1097    {
1098       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1099       {
1100          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1101          {
1102             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1103             {
1104                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1105                {
1106                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1107                         sizeof(SupportedSULFreqBandItem_t));
1108                }
1109                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1110                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1111
1112             }
1113             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1114          }
1115       }
1116       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1117    }
1118 }
1119
1120 /*******************************************************************
1121  *
1122  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1123  *
1124  * @details
1125  *
1126  *    Function : freeFddNrFreqInfo
1127  *
1128  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1129  *
1130  * @params[in]
1131  *
1132  * @return ROK     - void
1133  *
1134  * ****************************************************************/
1135 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1136 {
1137    uint8_t arrIdx =0;
1138
1139    if(fDD != NULLP)
1140    {
1141       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1142       {
1143          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1144                array[arrIdx], sizeof(FreqBandNrItem_t));
1145          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1146                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1147       }
1148
1149       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1150       {
1151          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1152                array[arrIdx], sizeof(FreqBandNrItem_t));
1153          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1154                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1155       }
1156       DU_FREE(fDD,sizeof(FDD_Info_t));
1157    }
1158 }
1159
1160 /*******************************************************************
1161  *
1162  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1163  *
1164  * @details
1165  *
1166  *    Function :  FreeServedCellList
1167  *
1168  *    Functionality:  deallocating the memory of function BuildServedCellList
1169
1170  *
1171  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1172  *
1173  * @return void
1174  *
1175  * ****************************************************************/
1176 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1177 {
1178    uint8_t   plmnCnt=MAX_PLMN;
1179    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1180    uint8_t  plmnIdx=0, sliceIdx=0;
1181    GNB_DU_Served_Cells_Item_t *srvCellItem;
1182    ServedPLMNs_Item_t  *servedPlmnItem;
1183    SliceSupportItem_t  *sliceSupportItem;
1184
1185    if(duServedCell->list.array!=NULLP)
1186    {
1187       if(duServedCell->list.array[0]!=NULLP)
1188       {
1189          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1190
1191          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1192                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1193          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1194                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1195
1196          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1197          {
1198             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1199                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1200             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1201          }
1202
1203          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1204          {
1205             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1206             {
1207                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1208                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1209
1210                if(servedPlmnItem->iE_Extensions != NULLP)
1211                {
1212                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1213                   {
1214                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1215                      {
1216                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1217                               SliceSupportList.list.array != NULLP)
1218                         {
1219                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1220                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1221                            {
1222                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1223                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1224                               {
1225                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1226                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1227
1228                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1229
1230                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1231                                  {
1232                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1233                                           sliceSupportItem->sNSSAI.sD->size);
1234                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1235                                  }
1236
1237                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1238                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1239                               }
1240                            }
1241                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1242                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1243                                  extensionValue.choice.SliceSupportList.list.size);
1244                         }
1245                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1246                               sizeof(ServedPLMNs_ItemExtIEs_t));
1247                      }
1248                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1249                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1250                   }
1251                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1252                }
1253                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1254                      sizeof(ServedPLMNs_Item_t));
1255             }
1256             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1257                   sizeof(ServedPLMNs_Item_t *));
1258          }
1259
1260          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1261          {
1262             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1263          }
1264          else
1265          {
1266             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1267             {
1268                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1269                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1270             }
1271          }
1272
1273          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1274                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1275
1276          if(srvCellItem->gNB_DU_System_Information != NULLP)
1277          {
1278             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1279             {
1280                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1281                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1282             }
1283
1284             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1285             {
1286                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1287                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1288             }
1289
1290             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1291          }
1292
1293          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1294       }
1295       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1296    }
1297 }
1298
1299 /*******************************************************************
1300  *
1301  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1302  *
1303  * @details
1304  *
1305  *    Function :  FreeF1SetupReq
1306  *
1307  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1308  *
1309  * @params[in] F1AP_PDU_t *f1apMsg
1310  *
1311  * @return void
1312  *
1313  * ****************************************************************/
1314 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1315 {
1316    uint8_t ieIdx, ieIdx2;
1317    F1SetupRequest_t *f1SetupReq=NULLP;
1318
1319    if(f1apMsg != NULLP)
1320    {
1321       if(f1apMsg->choice.initiatingMessage != NULLP)
1322       {
1323          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1324          if(f1SetupReq->protocolIEs.list.array != NULLP)
1325          {
1326             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1327             {
1328                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1329                {
1330                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1331                   {
1332                      case ProtocolIE_ID_id_TransactionID:
1333                         break;
1334                      case ProtocolIE_ID_id_gNB_DU_ID:
1335                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1336                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1337                         break;
1338                      case ProtocolIE_ID_id_gNB_DU_Name:
1339                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1340                               strlen((char *)duCfgParam.duName));
1341                         break;
1342                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1343                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1344                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1345                         break;
1346                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1347                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1348                         break;
1349                      default:
1350                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1351                         break;
1352                   }
1353                }
1354             }
1355             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1356             {
1357                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1358             }
1359             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1360                   f1SetupReq->protocolIEs.list.size);
1361          }
1362          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1363       }
1364       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1365    }
1366 }
1367 /*******************************************************************
1368  *
1369  * @brief Builds and Send the F1SetupRequest
1370  *
1371  * @details
1372  *
1373  *    Function : BuildAndSendF1SetupReq
1374  *
1375  * Functionality:Fills the F1SetupRequest
1376  *
1377  * @return ROK     - success
1378  *         RFAILED - failure
1379  *
1380  ******************************************************************/
1381 uint8_t BuildAndSendF1SetupReq()
1382 {
1383    uint8_t   ret, ieIdx, elementCnt;
1384    F1AP_PDU_t                 *f1apMsg = NULLP;
1385    F1SetupRequest_t           *f1SetupReq=NULLP;
1386    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1387    RRC_Version_t              *rrcVer=NULLP;
1388    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1389    ret= RFAILED;
1390
1391    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1392    do
1393    {
1394       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1395       if(f1apMsg == NULLP)
1396       {
1397          break;
1398       }
1399       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1400       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1401       if(f1apMsg->choice.initiatingMessage == NULLP)
1402       {
1403          break;
1404       }
1405       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1406       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1407       f1apMsg->choice.initiatingMessage->value.present = \
1408                                                          InitiatingMessage__value_PR_F1SetupRequest;
1409
1410       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1411
1412       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1413
1414       f1SetupReq->protocolIEs.list.count = elementCnt;
1415       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1416
1417       /* Initialize the F1Setup members */
1418       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1419       if(f1SetupReq->protocolIEs.list.array == NULLP)
1420       {
1421          break;
1422       }
1423       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1424       {
1425          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1426                sizeof(F1SetupRequestIEs_t));
1427          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1428          {
1429             break;
1430          }
1431       }
1432
1433       ieIdx = 0;
1434       /*TransactionID*/
1435       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1436       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1437       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1438                                                                F1SetupRequestIEs__value_PR_TransactionID;
1439       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1440                                                                              TRANS_ID;
1441
1442       /*DU ID*/
1443       ieIdx++;
1444       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1445       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1446       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1447                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1448       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1449                                                                              sizeof(uint8_t);
1450
1451       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1452             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1453       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1454             NULLP)
1455       {
1456          break;
1457       }
1458
1459       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1460          duCfgParam.duId;
1461
1462       /*DU Name*/
1463       if(duCfgParam.duName != NULL)
1464       {
1465          ieIdx++;
1466          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1467          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1468          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1469          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1470             strlen((char *)duCfgParam.duName);
1471          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1472                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1473          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1474                buf == NULLP)
1475          {
1476             break;
1477          }
1478          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1479                choice.GNB_DU_Name.buf,
1480                (char*)&duCfgParam.duName);
1481
1482       }
1483
1484       /*Served Cell list */
1485       ieIdx++;
1486       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1487                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1488       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1489       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1490                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1491       duServedCell = &f1SetupReq->protocolIEs.list.\
1492                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1493       if(BuildServedCellList(duServedCell))
1494       {
1495          break;
1496       }
1497       /*RRC Version*/
1498       ieIdx++;
1499       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1500                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1501       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1502       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1503                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1504       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1505       if(BuildRrcVer(rrcVer))
1506       {
1507          break;
1508       }
1509       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1510
1511       /* Encode the F1SetupRequest type as APER */
1512       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1513       encBufSize = 0;
1514       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1515             encBuf);
1516
1517       /* Encode results */
1518       if(encRetVal.encoded == ENCODE_FAIL)
1519       {
1520          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1521                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1522          break;
1523       }
1524       else
1525       {
1526          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1527          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1528          {
1529             printf("%x",encBuf[ieIdx]);
1530          }
1531
1532          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1533          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1534          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1535          {
1536              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1537              return RFAILED;
1538          }
1539          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1540       }
1541
1542       /* Sending msg */
1543       if(sendF1APMsg() != ROK)
1544       {
1545          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1546          break;
1547       }
1548
1549       ret=ROK;
1550       break;
1551    }while(true);
1552
1553    FreeF1SetupReq(f1apMsg);
1554
1555    return ret;
1556 }/* End of BuildAndSendF1SetupReq */
1557
1558 /*******************************************************************
1559  *
1560  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1561  *
1562  * @details
1563  *
1564  *    Function : freeCellsToModifyItem
1565  *
1566  *    Functionality: Deallocating memory of variables allocated in
1567  *                    BuildAndSendDUConfigUpdate function
1568  *
1569  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1570  *
1571  * @return ROK     - void
1572  *
1573  * ****************************************************************/
1574
1575 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1576 {
1577    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1578    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1579    SliceSupportItem_t *sliceSupportItem = NULLP;
1580
1581    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1582    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1583
1584    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1585            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1586    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1587          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1588
1589    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1590    {
1591       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1592       {
1593          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1594
1595          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1596
1597          if(servedPlmnItem->iE_Extensions != NULLP)
1598          {
1599             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1600             {
1601                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1602                {
1603                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1604                         list.array != NULLP)
1605                   {
1606                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1607                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1608                      {
1609                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1610                               list.array[sliceLstIdx] != NULLP)
1611                         {
1612
1613                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1614                                               SliceSupportList.list.array[sliceLstIdx];
1615
1616                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1617                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1618                            {
1619                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1620                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1621                            }
1622                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1623                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1624                         }
1625                      }
1626                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1627                            choice.SliceSupportList.list.array,\
1628                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1629                            extensionValue.choice.SliceSupportList.list.size);
1630                   }
1631                }
1632                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1633                {
1634                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1635                }
1636                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1637             }
1638             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1639          }
1640       }
1641       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1642       {
1643          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1644       }
1645       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1646          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1647    }
1648
1649    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1650    {
1651       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1652    }
1653    else
1654    {
1655       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1656       {
1657          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1658          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1659       }
1660    }
1661    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1662       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1663 }
1664
1665 /*******************************************************************
1666  *
1667  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1668  *
1669  * @details
1670  *
1671  *    Function : FreeDUConfigUpdate
1672  *
1673  *    Functionality: Deallocating memory of variables allocated in
1674  *                    BuildAndSendDUConfigUpdate function
1675  *
1676  * @params[in]  F1AP_PDU_t *f1apDuCfg
1677  *
1678  * @return ROK     - void
1679  *
1680  * ****************************************************************/
1681 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1682 {
1683    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1684    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1685    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1686    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1687    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1688    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1689
1690    if(f1apDuCfg != NULLP)
1691    {
1692       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1693       {
1694          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1695                        value.choice.GNBDUConfigurationUpdate;
1696          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1697          {
1698             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1699             {
1700                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1701                {
1702                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1703                   {
1704                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1705                         {
1706                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1707                                            value.choice.Served_Cells_To_Modify_List;
1708                            if(cellsToModify->list.array != NULLP)
1709                            {
1710                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1711                               {
1712                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1713                                  {
1714                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1715                                           Served_Cells_To_Modify_Item);
1716                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1717                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1718                                  }
1719                               }
1720                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1721                            }
1722                            break;
1723                         }
1724                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1725                         {
1726                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1727                                            value.choice.Served_Cells_To_Delete_List;
1728                            if(cellsToDelete->list.array != NULLP)
1729                            {
1730                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1731                               {
1732                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1733                                  {
1734                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1735                                           cellsToDelete->list.array[cellDeleteIdx]);
1736                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1737                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1738                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1739                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1740                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1741                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1742                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1743                                  }
1744                               }
1745                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1746                            }
1747
1748                            break;
1749                         }
1750                      case ProtocolIE_ID_id_gNB_DU_ID:
1751                         {
1752                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1753                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1754                            break;
1755                         }
1756                   }
1757                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1758                         sizeof(GNBDUConfigurationUpdateIEs_t));
1759                }
1760             }
1761             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1762          }
1763          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1764       }
1765       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1766    }
1767 }
1768
1769 /*******************************************************************
1770  *
1771  * @brief Fills Served Plmns required in ServCellInfo IE
1772  *
1773  * @details
1774  *
1775  *    Function : fillServedPlmns
1776  *
1777  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1778  *
1779  * @params[in] Pointer to ServedPLMNs_List_t *
1780  *
1781  * @return ROK     - success
1782  *         RFAILED - failure
1783  *
1784  *****************************************************************/
1785
1786 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1787 {
1788    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1789
1790    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1791    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1792          array[arrayIdx]->pLMN_Identity.size);
1793    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1794    {
1795       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1796       return RFAILED;
1797    }
1798    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1799          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1800    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1801    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1802    {
1803       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1804       return RFAILED;
1805    }
1806
1807    ieListCnt=1;
1808    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1809    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1810    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1811          iE_Extensions->list.size);
1812    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1813    {
1814       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1815       return RFAILED;
1816    }
1817    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1818    {
1819       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1820             sizeof(ServedPLMNs_ItemExtIEs_t));
1821       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1822       {
1823          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1824          return RFAILED;
1825       }
1826    }
1827
1828    ieIdx = 0;
1829    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1830    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1831    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1832    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1833    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1834    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1835       list.count = elementCnt;
1836    servedPlmn->list.array[arrayIdx]->\
1837       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1838       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1839    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1840          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1841          list.array,servedPlmn->list.array[arrayIdx]->\
1842          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1843    if(servedPlmn->list.array[arrayIdx]->\
1844          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1845          list.array == NULLP)
1846    {
1847       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1848       return RFAILED;
1849    }
1850
1851    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1852    {
1853       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1854       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1855       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1856       if(servedPlmn->list.array[arrayIdx]->\
1857       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1858       list.array[sliceLstIdx] == NULLP)
1859       {
1860          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1861          return RFAILED;
1862       }
1863
1864       servedPlmn->list.array[arrayIdx]->\
1865       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1866       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1867       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1868       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1869       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1870       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1871       sNSSAI.sST.size);
1872
1873       if(servedPlmn->list.array[arrayIdx]->\
1874       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1875       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1876       {
1877          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1878          return RFAILED;
1879       }
1880       servedPlmn->list.array[arrayIdx]->\
1881       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1882       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1883       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1884
1885       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1886       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1887       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1888       if(servedPlmn->list.array[arrayIdx]->\
1889       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1890       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1891       {
1892          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1893          return RFAILED;
1894       }
1895       servedPlmn->list.array[arrayIdx]->\
1896       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1897       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1898       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1899       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1900       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1901       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1902       list.array[sliceLstIdx]->sNSSAI.sD->size);
1903       if(servedPlmn->list.array[arrayIdx]->\
1904       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1905       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1906       {
1907          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1908          return RFAILED;
1909       }
1910       memcpy(servedPlmn->list.array[arrayIdx]->\
1911       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1912       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1913       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1914       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1915       list.array[sliceLstIdx]->sNSSAI.sD->size);
1916    }
1917    return ROK;
1918 }
1919
1920 /*******************************************************************
1921  *
1922  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1923  *
1924  * @details
1925  *
1926  *    Function : fillNrFddInfo
1927  *
1928  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1929  *
1930  * @params[in] FDD_Info_t *fDD
1931  *
1932  * @return ROK     - success
1933  *         RFAILED - failure
1934  *
1935  *****************************************************************/
1936
1937 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1938 {
1939    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1940       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1941    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1942    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1943    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1944          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1945    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1946    {
1947       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1948       return RFAILED;
1949    }
1950
1951    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1952       sizeof(FreqBandNrItem_t));
1953    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1954    {
1955       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1956       return RFAILED;
1957    }
1958
1959    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1960       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1961       freqBand[0].nrFreqBand;
1962    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1963    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1964       dlNrFreqInfo.nrArfcn;
1965    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
1966    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1967    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1968    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1969    {
1970       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1971       return RFAILED;
1972    }
1973
1974    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
1975    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1976    {
1977       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1978       return RFAILED;
1979    }
1980
1981    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1982       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1983       freqBand[0].nrFreqBand;
1984    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1985
1986    /*Transmission Bandwidth*/
1987    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1988       f1Mode.mode.fdd.ulTxBw.nrScs;
1989    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1990       f1Mode.mode.fdd.ulTxBw.nrb;
1991    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1992       f1Mode.mode.fdd.dlTxBw.nrScs;
1993    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1994       f1Mode.mode.fdd.dlTxBw.nrb;
1995
1996    return ROK;
1997 }
1998
1999 /*******************************************************************
2000  *
2001  * @brief Fills ServCellInfo IE
2002  *
2003  * @details
2004  *
2005  *    Function : fillServedCellInfo
2006  *
2007  *    Functionality: Fills ServCellInfo
2008  *
2009  * @params[in] Pointer to Served_Cell_Information_t *
2010  *
2011  * @return ROK     - success
2012  *         RFAILED - failure
2013  *
2014  *****************************************************************/
2015
2016 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2017 {
2018    uint8_t ieIdx, ieListCnt;
2019
2020    /*nRCGI*/
2021    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2022    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2023          srvCellInfo->nRCGI.pLMN_Identity.size);
2024    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2025    {
2026       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2027       return RFAILED;
2028    }
2029    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2030          srvCellInfo->nRCGI.pLMN_Identity.buf);
2031    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2032    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2033          srvCellInfo->nRCGI.nRCellIdentity.size);
2034    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2035    {
2036       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2037       return RFAILED;
2038    }
2039
2040    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2041    /*nRPCI*/
2042    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2043
2044    /*servedPLMNs*/
2045    ieListCnt = 1;
2046    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2047    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2048    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2049    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2050    {
2051       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2052       return RFAILED;
2053    }
2054    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2055    {
2056       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2057       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2058       {
2059          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2060          return RFAILED;
2061       }
2062    }
2063    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2064    {
2065       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2066       return RFAILED;
2067    }
2068
2069 #ifndef NR_TDD
2070    /*nR Mode Info with FDD*/
2071    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2072    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2073    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2074    {
2075       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2076       return RFAILED;
2077    }
2078    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2079    {
2080        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2081       return RFAILED;
2082    }
2083 #else
2084    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2085    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2086    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2087    {
2088       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2089       return RFAILED;
2090    }
2091    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2092    {
2093       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2094       return RFAILED;
2095    }
2096 #endif
2097
2098    /*Measurement timing Config*/
2099    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2100    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2101          buf,srvCellInfo->measurementTimingConfiguration.size);
2102    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2103    {
2104       return RFAILED;
2105    }
2106    srvCellInfo->measurementTimingConfiguration.\
2107          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2108
2109    return ROK;
2110 }
2111
2112 /*******************************************************************
2113  *
2114  * @brief Fills ServCellToModItem IE
2115  *
2116  * @details
2117  *
2118  *    Function : fillServCellToModItem
2119  *
2120  *    Functionality: Fills ServCellToModItem IE
2121  *
2122  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2123  *
2124  * @return ROK     - success
2125  *         RFAILED - failure
2126  *
2127  *****************************************************************/
2128
2129 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2130 {
2131    /*pLMN_Identity*/
2132    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2133    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2134    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2135    {
2136       return RFAILED;
2137    }
2138    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2139          modifyItem->oldNRCGI.pLMN_Identity.buf);
2140
2141    /*nRCellIdentity*/
2142    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2143    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2144          modifyItem->oldNRCGI.nRCellIdentity.size);
2145    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2146    {
2147       return RFAILED;
2148    }
2149    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2150
2151    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2152       return RFAILED;
2153    else
2154       return ROK;
2155 }
2156
2157 /*******************************************************************
2158  *
2159  * @brief Builds ServCellToModList
2160  *
2161  * @details
2162  *
2163  *    Function : buildServCellToModList
2164  *
2165  *    Functionality: Builds the serv cell to Mod List
2166  *
2167  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2168  *
2169  * @return ROK     - success
2170  *         RFAILED - failure
2171  *
2172  *****************************************************************/
2173
2174 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2175 {
2176    uint8_t ieListCnt, ieIdx;
2177    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2178
2179    ieListCnt = 1;
2180    cellsToModify->list.count = ieListCnt;
2181    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2182    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2183    if(cellsToModify->list.array == NULLP)
2184    {
2185       return RFAILED;
2186    }
2187    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2188    {
2189       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2190       if(cellsToModify->list.array[ieIdx] == NULLP)
2191       {
2192          return RFAILED;
2193       }
2194    }
2195    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2196    cellsToModify->list.array[0]->criticality = Criticality_reject;
2197    cellsToModify->list.array[0]->value.present =\
2198       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2199    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2200
2201    if(fillServCellToModItem(modifyItem))
2202       return RFAILED;
2203    else
2204       return ROK;
2205 }
2206 /*******************************************************************
2207  *
2208  * @brief filling the DeleteItemList
2209  *
2210  * @details
2211  *
2212  *    Function : fillCellToDeleteItem
2213  *
2214  *    Functionality: Filling the DeleteItemIe
2215  *
2216  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2217  *
2218  * @return ROK     - success
2219  *         RFAILED - failure
2220  *
2221  *****************************************************************/
2222 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2223 {
2224    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2225
2226    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2227    deleteItemIe->criticality = Criticality_reject;
2228    deleteItemIe->value.present =\
2229    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2230    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2231
2232    /*pLMN_Identity*/
2233    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2234    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2235    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2236    {
2237       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2238       return RFAILED;
2239    }
2240    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2241          deleteItem->oldNRCGI.pLMN_Identity.buf);
2242
2243    /*nRCellIdentity*/
2244    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2245    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2246          deleteItem->oldNRCGI.nRCellIdentity.size);
2247    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2248    {
2249       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2250       return RFAILED;
2251    }
2252    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2253    return ROK;
2254 }
2255 /*******************************************************************
2256  *
2257  * @brief Builds ServCellToDeleteList
2258  *
2259  * @details
2260  *
2261  *    Function : buildServCellToDeleteList
2262  *
2263  *    Functionality: Builds the serv cell to delete List
2264  *
2265  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2266  *
2267  * @return ROK     - success
2268  *         RFAILED - failure
2269  *
2270  *****************************************************************/
2271
2272 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2273 {
2274    uint8_t ieListCnt, arrIdx;
2275
2276    ieListCnt = 1;
2277    cellsToDelete->list.count = ieListCnt;
2278    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2279
2280    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2281    if(cellsToDelete->list.array == NULLP)
2282    {
2283       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2284       return RFAILED;
2285    }
2286
2287    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2288    {
2289       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2290       if(cellsToDelete->list.array[arrIdx] == NULLP)
2291       {
2292          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2293          return RFAILED;
2294       }
2295    }
2296
2297    arrIdx=0;
2298    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2299    {
2300       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2301       return RFAILED;
2302    }
2303    return ROK;
2304 }
2305
2306 /*******************************************************************
2307  *
2308  * @brief Builds and sends the DUConfigUpdate
2309  *
2310  * @details
2311  *
2312  *    Function : BuildAndSendDUConfigUpdate
2313  *
2314  *    Functionality: Constructs the DU Update message and sends
2315  *                   it to the CU through SCTP.
2316  *
2317  * @params[in] void **buf,Buffer to which encoded pattern is written into
2318  * @params[in] int *size,size of buffer
2319  *
2320  * @return ROK     - success
2321  *         RFAILED - failure
2322  *
2323  * ****************************************************************/
2324 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2325 {
2326    uint8_t ret =0, ieIdx=0, elementCnt=0;
2327    bool memAlloctionFailure = false;
2328    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2329    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2330    asn_enc_rval_t encRetVal;     /* Encoder return value */
2331
2332    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2333    ret= RFAILED;
2334
2335    while(true)
2336    {
2337       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2338       /* Allocate the memory for F1DuCfg */
2339       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2340       if(f1apDuCfg == NULLP)
2341       {
2342          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2343          break;
2344       }
2345
2346       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2347       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2348       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2349       {
2350          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2351          break;
2352       }
2353
2354       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2355                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2356       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2357       f1apDuCfg->choice.initiatingMessage->value.present = \
2358                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2359       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2360                     choice.GNBDUConfigurationUpdate;
2361       elementCnt = 3;
2362       duCfgUpdate->protocolIEs.list.count = elementCnt;
2363       duCfgUpdate->protocolIEs.list.size = \
2364                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2365
2366       /* Initialize the F1Setup members */
2367       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2368       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2369       {
2370          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2371          break;
2372       }
2373       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2374       {
2375          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2376          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2377          {
2378             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2379             memAlloctionFailure = true;
2380             break;
2381          }
2382       }
2383
2384       if(memAlloctionFailure == true)
2385       {
2386          break;
2387       }
2388       /*TransactionID*/
2389       ieIdx = 0;
2390       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2391       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2392       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2393       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2394       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2395
2396       ieIdx++;
2397       if(servCellAction == SERV_CELL_TO_MODIFY)
2398       {
2399          /*Served Cell to Modify */
2400          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2401          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2402          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2403          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2404          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2405          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2406                   Served_Cells_To_Modify_List))
2407          {
2408             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2409             break;
2410          }
2411       }
2412       else
2413       {
2414          /*Served Cell to Delete */
2415          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2416          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2417          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2418          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2419          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2420          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2421          Served_Cells_To_Delete_List)!=ROK)
2422          {
2423             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2424             break;
2425          }
2426
2427       }
2428       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2429       /*GNB DU ID */
2430       ieIdx++;
2431       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2432       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2433       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2434       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2435       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2436       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2437             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2438       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2439       {
2440          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2441          break;
2442       }
2443       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2444
2445       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2446
2447       /* Encode the DU Config Update type as APER */
2448       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2449       encBufSize = 0;
2450       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2451
2452       /* Checking encode results */
2453       if(encRetVal.encoded == ENCODE_FAIL)
2454       {
2455          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2456                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2457          break;
2458       }
2459       else
2460       {
2461          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2462          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2463          {
2464             printf("%x",encBuf[ieIdx]);
2465          }
2466       }
2467       /* Sending msg */
2468       if(sendF1APMsg() != ROK)
2469       {
2470          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2471          break;
2472       }
2473
2474       ret = ROK;
2475       break;
2476    }
2477
2478    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2479    return ret;
2480 }
2481
2482
2483 /*******************************************************************
2484  *
2485  * @brief free the ULRRCMessageTransfer
2486  *
2487  * @details
2488  *
2489  *    Function : FreeULRRCMessageTransfer
2490  *
2491  *    Functionality: Deallocating the memory of variable allocated in
2492  *                      FreeULRRCMessageTransfer
2493  *
2494  * @params[in]
2495  *
2496  * @return ROK     - void
2497  *
2498  ******************************************************************/
2499 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2500 {
2501    uint8_t idx1;
2502    ULRRCMessageTransfer_t  *ulRRCMsg;
2503
2504    if(f1apMsg != NULLP)
2505    {
2506       if(f1apMsg->choice.initiatingMessage != NULLP)
2507       {
2508          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2509          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2510          {
2511             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2512             {
2513                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2514                {
2515                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2516                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2517                   {
2518                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2519                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2520                   }
2521                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2522                }
2523             }
2524             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2525          }
2526          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2527       }
2528       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2529    }
2530 }
2531 /*******************************************************************
2532  *
2533  * @brief Builds and sends the ULRRCMessageTransfer
2534  *
2535  * @details
2536  *
2537  *    Function : BuildAndSendULRRCMessageTransfer
2538  *
2539  *    Functionality: Constructs the UL RRC Message Transfer and sends
2540  *                   it to the CU through SCTP.
2541  *
2542  * @params[in]
2543  *
2544  * @return ROK     - success
2545  *         RFAILED - failure
2546  *
2547  * ****************************************************************/
2548 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2549       uint16_t msgLen, uint8_t *rrcMsg)
2550 {
2551    uint8_t   elementCnt =0;
2552    uint8_t   idx1 =0;
2553    uint8_t   idx =0;
2554    F1AP_PDU_t                   *f1apMsg = NULLP;
2555    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2556    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2557    uint8_t ret =RFAILED;
2558
2559    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2560
2561    while(true)
2562    {
2563       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2564
2565       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2566       if(f1apMsg == NULLP)
2567       {
2568          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2569          break;
2570       }
2571       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2572       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2573       if(f1apMsg->choice.initiatingMessage == NULLP)
2574       {
2575          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2576          break;
2577       }
2578       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2579       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2580       f1apMsg->choice.initiatingMessage->value.present = \
2581                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2582       ulRRCMsg =
2583          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2584       elementCnt = 4;
2585       ulRRCMsg->protocolIEs.list.count = elementCnt;
2586       ulRRCMsg->protocolIEs.list.size = \
2587                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2588
2589       /* Initialize the F1Setup members */
2590       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2591       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2592       {
2593          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2594          break;
2595       }
2596       for(idx=0; idx<elementCnt; idx++)
2597       {
2598          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2599          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2600          {
2601             break;
2602          }
2603       }
2604
2605       idx1 = 0;
2606
2607       /*GNB CU UE F1AP ID*/
2608       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2609       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2610       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2611                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2612       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2613
2614       /*GNB DU UE F1AP ID*/
2615       idx1++;
2616       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2617       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2618       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2619                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2620       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2621
2622       /*SRBID*/
2623       idx1++;
2624       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2625       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2626       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2627                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2628       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2629
2630       /*RRCContainer*/
2631       idx1++;
2632       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2633       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2634       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2635                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2636       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2637       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2638             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2639       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2640       {
2641          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2642          break;
2643       }
2644       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2645       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2646             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2647
2648       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2649
2650       /* Encode the F1SetupRequest type as APER */
2651       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2652       encBufSize = 0;
2653       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2654             encBuf);
2655       /* Encode results */
2656       if(encRetVal.encoded == ENCODE_FAIL)
2657       {
2658          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2659                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2660          break;
2661       }
2662       else
2663       {
2664          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2665          for(int i=0; i< encBufSize; i++)
2666          {
2667             printf("%x",encBuf[i]);
2668          }
2669       }
2670
2671       /* Sending  msg  */
2672       if(sendF1APMsg()  !=      ROK)
2673       {
2674          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2675          break;
2676       }
2677       ret = ROK;
2678       break;
2679    }
2680    FreeULRRCMessageTransfer(f1apMsg);
2681
2682    return ret;
2683 }/* End of BuildAndSendULRRCMessageTransfer*/
2684
2685 /*******************************************************************
2686  *
2687  * @brief Builds tag config
2688  *
2689  * @details
2690  *
2691  *    Function : BuildTagConfig
2692  *
2693  *    Functionality: Builds tag config in MacCellGroupConfig
2694  *
2695  * @params[in] TAG_Config *tag_Config
2696  *
2697  * @return ROK     - success
2698  *         RFAILED - failure
2699  *
2700  * ****************************************************************/
2701 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2702 {
2703    struct TAG_Config__tag_ToAddModList *tagList;
2704    uint8_t                     idx, elementCnt;
2705
2706    tagConfig->tag_ToReleaseList = NULLP;
2707    tagConfig->tag_ToAddModList = NULLP;
2708    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2709    if(!tagConfig->tag_ToAddModList)
2710    {
2711       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2712       return RFAILED;
2713    }
2714
2715    if(ueCb == NULLP)
2716       elementCnt = ODU_VALUE_ONE;
2717    else
2718       elementCnt = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2719
2720    tagList = tagConfig->tag_ToAddModList;
2721    tagList->list.count = elementCnt;
2722    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2723
2724    tagList->list.array = NULLP;
2725    DU_ALLOC(tagList->list.array, tagList->list.size);
2726    if(!tagList->list.array)
2727    {
2728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2729       return RFAILED;
2730    }
2731
2732    for(idx=0; idx<tagList->list.count; idx++)
2733    {
2734       tagList->list.array[idx] = NULLP;
2735       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2736       if(!tagList->list.array[idx])
2737       {
2738          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2739          return RFAILED;
2740       }
2741    }
2742
2743    if(ueCb == NULLP)
2744    {
2745       idx = 0;
2746       tagList->list.array[idx]->tag_Id = TAG_ID;
2747       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2748    }
2749    else
2750    {
2751       for(idx=0; idx<tagList->list.count; idx++)
2752       {
2753          tagList->list.array[idx]->tag_Id = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2754          tagList->list.array[idx]->timeAlignmentTimer = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2755       }
2756    }
2757
2758    return ROK;
2759 }
2760
2761 /*******************************************************************
2762  *
2763  * @brief Builds PHR Config
2764  *
2765  * @details
2766  *
2767  *    Function : BuildPhrConfig
2768  *
2769  *    Functionality: Builds phrConfig in MacCellGroupConfig
2770  *
2771  * @params[in] PHR Config *
2772  *
2773  * @return ROK     - success
2774  *         RFAILED - failure
2775  *
2776  * ****************************************************************/
2777 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2778 {
2779
2780    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2781    phrConfig->choice.setup = NULLP;
2782    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2783    if(!phrConfig->choice.setup)
2784    {
2785       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2786       return RFAILED;
2787    }
2788
2789    if(ueCb == NULLP)
2790    {
2791       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2792       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2793       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2794       phrConfig->choice.setup->multiplePHR              = false;
2795       phrConfig->choice.setup->dummy                    = false;
2796       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2797       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2798    }
2799    else
2800    {
2801       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2802       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2803       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->macUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2804       phrConfig->choice.setup->multiplePHR              = ueCb->macUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2805       phrConfig->choice.setup->dummy                    = ueCb->macUeCfg.macCellGrpCfg.phrCfg.dummy;
2806       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2807       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2808    }
2809
2810    return ROK;
2811 }
2812
2813 /*******************************************************************
2814  *
2815  * @brief Builds BSR Config
2816  *
2817  * @details
2818  *
2819  *    Function : BuildBsrConfig
2820  *
2821  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2822  *
2823  * @params[in] BSR_Config *bsrConfig
2824  *
2825  * @return ROK     - success
2826  *         RFAILED - failure
2827  *
2828  * ****************************************************************/
2829 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2830 {
2831    if(ueCb == NULLP)
2832    {
2833       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2834       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2835       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2836    }
2837    else
2838    {
2839       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2840       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2841
2842       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2843       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2844       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2845       {
2846          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2847          return RFAILED;
2848       }
2849       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2850    }
2851
2852    return ROK;
2853 }
2854
2855 /*******************************************************************
2856  *
2857  * @brief Builds scheduling request config
2858  *
2859  * @details
2860  *
2861  *    Function : BuildSchedulingReqConfig
2862  *
2863  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2864  *
2865  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2866  *
2867  * @return ROK     - success
2868  *         RFAILED - failure
2869  *
2870  * ****************************************************************/
2871 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2872 {
2873    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2874    uint8_t                     idx, elementCnt;
2875
2876    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2877    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2878          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2879    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2880    {
2881       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2882       return RFAILED;
2883    }
2884
2885    if(ueCb == NULLP)
2886       elementCnt = ODU_VALUE_ONE;
2887    else
2888       elementCnt = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2889
2890    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2891    schReqList->list.count = elementCnt;
2892    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2893
2894    schReqList->list.array = NULLP;
2895    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2896    if(!schReqList->list.array)
2897    {
2898       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2899       return RFAILED;
2900    }
2901
2902    for(idx=0; idx<schReqList->list.count; idx++)
2903    {
2904       schReqList->list.array[idx] = NULLP;
2905       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2906       if(!schReqList->list.array[idx])
2907       {
2908          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2909          return RFAILED;
2910       }
2911    }
2912
2913    if(ueCb == NULLP)
2914    {
2915       idx = 0;
2916       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2917
2918       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2919       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2920       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2921       {
2922          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2923          return RFAILED;
2924       }
2925       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2926       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2927    }
2928    else
2929    {
2930       for(idx=0; idx<schReqList->list.count; idx++)
2931       {
2932          schReqList->list.array[idx]->schedulingRequestId = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2933
2934          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2935          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2936          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2937          {
2938             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2939             return RFAILED;
2940          }
2941          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2942          schReqList->list.array[idx]->sr_TransMax = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2943       }
2944    }
2945
2946    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2947
2948    return ROK;
2949 }
2950
2951 /*******************************************************************
2952  *
2953  * @brief Builds RLC Configuration for AM mode
2954  *
2955  * @details
2956  *
2957  *    Function : BuildRlcConfigAm
2958  *
2959  *    Functionality:
2960  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
2961  *
2962  * @params[in] AmBearerCfg *amCfg
2963  *             RLC_Config_t  *rlcConfig
2964  *
2965  * @return ROK     - success
2966  *         RFAILED - failure
2967  *
2968  * ****************************************************************/
2969 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
2970 {
2971    rlcConfig->choice.am = NULLP;
2972    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2973    if(!rlcConfig->choice.am)
2974    {
2975       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2976       return RFAILED;
2977    }
2978
2979    /* Fill AM UL configuration */
2980    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2981    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2982    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2983    {
2984       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2985       return RFAILED;
2986    }
2987
2988    /* Fill default AM UL configuration if input pointer to DU database is NULL */
2989    if(amCfg == NULLP)
2990    {
2991       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2992       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2993       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2994       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2995       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2996    }
2997    else
2998    {
2999       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
3000       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
3001       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
3002       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
3003       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
3004    }
3005
3006    /* Fill AM DL configuraion */
3007    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3008    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3009    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3010    {
3011       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3012       return RFAILED;
3013    }
3014
3015    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3016    if(amCfg == NULLP)
3017    {
3018       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3019       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3020       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3021    }
3022    else /* Fill AM configuration from DU database */
3023    {
3024       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3025       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3026       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3027    }
3028    return ROK;
3029 }
3030
3031 /*******************************************************************
3032  *
3033  * @brief Builds RLC Config for UM Bidirection
3034  *
3035  * @details
3036  *
3037  *    Function : BuildRlcConfig UmBiDir
3038  *
3039  *    Functionality:
3040  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3041  *
3042  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3043  *             RLC_Config_t *rlcConfig
3044  *
3045  * @return ROK     - success
3046  *         RFAILED - failure
3047  *
3048  * ****************************************************************/
3049 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3050 {
3051    rlcConfig->choice.um_Bi_Directional = NULLP;
3052    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3053    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3054    {
3055       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3056       return RFAILED;
3057    }
3058
3059    /* Fill UM Bidirectional UL configuration */
3060    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3061    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3062    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3063    {
3064       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3065       return RFAILED;
3066    }
3067
3068    if(umBiDirCfg != NULLP)
3069    {
3070       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3071    }
3072
3073    /* Fill UM Bidirectional DL configuration */
3074    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3075    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3076    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3077    {
3078       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3079       return RFAILED;
3080    }
3081
3082    if(umBiDirCfg != NULLP)
3083    {
3084       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3085       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3086    }
3087
3088    return ROK;
3089 }
3090
3091 /*******************************************************************
3092  *
3093  * @brief Builds RLC Config for UM Uni directional UL
3094  *
3095  * @details
3096  *
3097  *    Function : BuildRlcConfigUmUniDirUl
3098  *
3099  *    Functionality:
3100  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3101  *
3102  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3103  *             RLC_Config_t *rlcConfig
3104  *
3105  * @return ROK     - success
3106  *         RFAILED - failure
3107  *
3108  * ****************************************************************/
3109 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3110 {
3111    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3112    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3113    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3114    {
3115       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3116       return RFAILED;
3117    }
3118
3119    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3120    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3121    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3122    {
3123       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3124       return RFAILED;
3125    }
3126
3127    if(umUniDirDlCfg != NULLP)
3128    {
3129       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3130    }
3131
3132    return ROK;
3133 }
3134
3135 /*******************************************************************
3136  *
3137  * @brief Builds RLC Config for UM Uni directional DL
3138  *
3139  * @details
3140  *
3141  *    Function : BuildRlcConfigUmUniDirDl
3142  *
3143  *    Functionality:
3144  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3145  *
3146  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3147  *             RLC_Config_t *rlcConfig
3148  *
3149  * @return ROK     - success
3150  *         RFAILED - failure
3151  *
3152  * ****************************************************************/
3153 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3154 {
3155    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3156    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3157    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3158    {
3159       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3160       return RFAILED;
3161    }
3162
3163    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3164    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3165    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3166    {
3167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3168       return RFAILED;
3169    }
3170
3171    if(umUniDirUlCfg != NULLP)
3172    {
3173       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3174       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3175    }
3176
3177    return ROK;
3178 }
3179
3180 /*******************************************************************
3181  *
3182  * @brief Builds RLC Config
3183  *
3184  * @details
3185  *
3186  *    Function : BuildRlcConfig
3187  *
3188  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3189  *
3190  * @params[in] RLC_Config_t *rlcConfig
3191  *
3192  * @return ROK     - success
3193  *         RFAILED - failure
3194  *
3195  * ****************************************************************/
3196 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3197 {
3198
3199    /* Fill default values if rbCfg is NULL */
3200    if(rbCfg == NULLP)
3201    {
3202       rlcConfig->present = RLC_Config_PR_am;
3203       BuildRlcConfigAm(NULLP, rlcConfig);
3204    }
3205    /* If RbCfg is present, fill RLC configurations from DU Database */
3206    else
3207    {
3208       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3209       switch(rlcConfig->present)
3210       {
3211          case RLC_Config_PR_am:
3212             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3213             break;
3214          case RLC_Config_PR_um_Bi_Directional:
3215             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3216             break;
3217          case RLC_Config_PR_um_Uni_Directional_UL:
3218             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3219             break;
3220          case RLC_Config_PR_um_Uni_Directional_DL:
3221             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3222             break;
3223          case RLC_Config_PR_NOTHING:
3224          default:
3225             break;
3226       }
3227    }
3228
3229    return ROK;
3230 }
3231
3232 /*******************************************************************
3233  *
3234  * @brief Builds MAC LC Config
3235  *
3236  * @details
3237  *
3238  *    Function : BuildMacLCConfig
3239  *
3240  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3241  *
3242  * @params[in] struct LogicalChannelConfig macLcConfig
3243  *
3244  * @return ROK     - success
3245  *         RFAILED - failure
3246  *
3247  * ****************************************************************/
3248 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3249 {
3250    macLcConfig->ul_SpecificParameters = NULLP;
3251    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3252    if(!macLcConfig->ul_SpecificParameters)
3253    {
3254       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3255       return RFAILED;
3256    }
3257
3258    if(lcCfgDb == NULLP)
3259    {
3260       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3261       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3262       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3263    }
3264    else
3265    {
3266       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3267       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3268       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3269    }
3270
3271    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3272    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3273    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3274    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3275
3276    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3277    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3278    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3279    {
3280       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3281       return RFAILED;
3282    }
3283
3284    if(lcCfgDb == NULLP)
3285       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3286    else
3287       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3288
3289    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3290    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3291    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3292    {
3293       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3294       return RFAILED;
3295    }
3296
3297    if(lcCfgDb == NULLP)
3298       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3299    else
3300       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3301
3302    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3303    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3304    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3305
3306    return ROK;
3307 }
3308
3309 /*******************************************************************
3310  *
3311  * @brief Builds RLC Bearer to Add/Mod list
3312  *
3313  * @details
3314  *
3315  *    Function :BuildRlcBearerToAddModList
3316  *
3317  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3318  *
3319  * @params[in] rlc_BearerToAddModList
3320  *
3321  * @return ROK     - success
3322  *         RFAILED - failure
3323  *
3324  * ****************************************************************/
3325 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3326 {
3327    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3328
3329    if(ueCb == NULLP)
3330       elementCnt = 1;
3331    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3332       elementCnt = ueCb->rlcUeCfg.numLcs;
3333    else
3334    {
3335       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3336       {
3337          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3338             elementCnt++;
3339       }
3340    }
3341    rlcBearerList->list.count = elementCnt;
3342    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3343
3344    rlcBearerList->list.array = NULLP;
3345    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3346    if(!rlcBearerList->list.array)
3347    {
3348       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3349       return RFAILED;
3350    }
3351
3352    for(idx=0; idx<rlcBearerList->list.count; idx++)
3353    {
3354       rlcBearerList->list.array[idx] = NULLP;
3355       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3356       if(!rlcBearerList->list.array[idx])
3357       {
3358          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3359          return RFAILED;
3360       }
3361    }
3362
3363    if(ueCb == NULLP)
3364    {
3365       idx=0;
3366       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3367       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3368       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3369       {
3370          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3371          return RFAILED;
3372       }
3373       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3374       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3375       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3376
3377       /* Fill RLC related Configurations for this Radio Bearer */
3378       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3379       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3380       if(!rlcBearerList->list.array[idx]->rlc_Config)
3381       {
3382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3383          return RFAILED;
3384       }
3385       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3386       {
3387          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3388          return RFAILED;
3389       }
3390
3391       /* Fill MAC related configurations for this Radio Bearer */
3392       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3393       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3394       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3395       {
3396          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3397          return RFAILED;
3398       }
3399       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3400       {
3401          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3402          return RFAILED;
3403       }
3404    }
3405    else
3406    {
3407       idx=0;
3408       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3409       {
3410          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3411             continue;
3412
3413          /* Fill Logical channel identity */
3414          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3415
3416          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3417          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3418          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3419          {
3420             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3421             return RFAILED;
3422          }
3423          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3424                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3425          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3426          {
3427             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3428                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3429                break;
3430             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3431                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3432                break;
3433             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3434             default:
3435                break;
3436          }
3437          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3438
3439          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3440
3441          /* Fill RLC related Configurations for this Radio Bearer */
3442          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3443          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3444          if(!rlcBearerList->list.array[idx]->rlc_Config)
3445          {
3446             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3447             return RFAILED;
3448          }
3449          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3450          {
3451             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3452             return RFAILED;
3453          }
3454
3455          /* Fill MAC related configurations for this Radio Bearer */
3456          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3457          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3458          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3459          {
3460             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3461             return RFAILED;
3462          }
3463          for(macLcIdx = 0; macLcIdx < ueCb->macUeCfg.numLcs; macLcIdx++)
3464          {
3465             if(ueCb->macUeCfg.lcCfgList[macLcIdx].lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3466             {
3467                if(BuildMacLCConfig(&ueCb->macUeCfg.lcCfgList[macLcIdx], rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3468                {
3469                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3470                   return RFAILED;
3471                }
3472                break;
3473             }
3474          }
3475
3476          idx++;
3477       }
3478    }
3479    return ROK;
3480 }
3481
3482 /*******************************************************************
3483  *
3484  * @brief Build Control resource set to add/modify list
3485  *
3486  * @details
3487  *
3488  *    Function : BuildControlRSetToAddModList
3489  *
3490  *    Functionality: Build Control resource set to add/modify list
3491  *
3492  * @params[in]
3493  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3494  *
3495  * @return ROK     - success
3496  *         RFAILED - failure
3497  *
3498  * ****************************************************************/
3499 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3500 {
3501    uint8_t idx;
3502    uint8_t elementCnt;
3503    uint8_t numBytes, bitsUnused;
3504    struct ControlResourceSet *controlRSet;
3505    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3506    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3507
3508    if(pdcchCfg == NULLP)
3509       elementCnt = 1;
3510    else
3511       elementCnt = pdcchCfg->numCRsetToAddMod;
3512
3513    controlRSetList->list.count = elementCnt;
3514    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3515
3516    controlRSetList->list.array = NULLP;
3517    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3518    if(!controlRSetList->list.array)
3519    {
3520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3521       return RFAILED;
3522    }
3523
3524    for(idx = 0; idx < elementCnt; idx++)
3525    {
3526       controlRSetList->list.array[idx] = NULLP;
3527       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3528       if(!controlRSetList->list.array[idx])
3529       {
3530          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3531          return RFAILED;
3532       }
3533    }
3534
3535    for(idx = 0; idx < elementCnt; idx++)
3536    {
3537       controlRSet = controlRSetList->list.array[idx];
3538
3539       if(pdcchCfg == NULLP)
3540          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3541       else
3542          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3543
3544       /* size 6 bytes
3545        * 3 LSBs unsued
3546        * Bit string stored ff0000000000
3547        */
3548       numBytes = 6;
3549       bitsUnused = 3;
3550       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3551
3552       controlRSet->frequencyDomainResources.buf = NULLP;
3553       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3554       if(!controlRSet->frequencyDomainResources.buf)
3555       {
3556          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3557          return RFAILED;
3558       }
3559
3560       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3561
3562       if(pdcchCfg == NULLP)
3563       {
3564          coreset0EndPrb = CORESET0_END_PRB;
3565          coreset1StartPrb = coreset0EndPrb + 6;
3566          coreset1NumPrb = CORESET1_NUM_PRB;
3567          /* calculate the PRBs */
3568          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3569          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3570          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3571
3572          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3573          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3574          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3575       }
3576       else
3577       {
3578          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3579          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3580          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3581          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3582          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3583       }
3584       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3585       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3586       controlRSet->tci_PresentInDCI = NULLP;
3587
3588 #if 0
3589       uint8_t tciStateIdx;
3590
3591       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3592             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3593       if(!controlRset->tci_StatesPDCCH_ToAddList)
3594       {
3595          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3596          return RFAILED;
3597       }
3598
3599       elementCnt = 1;
3600       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3601       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3602       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3603             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3604          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3605          {
3606             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3607             return RFAILED;
3608          }
3609
3610       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3611       {
3612          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3613          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3614          {
3615             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3616             return RFAILED;
3617          }
3618       }
3619
3620       tciStateIdx = 0;
3621       /* TODO */
3622       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3623
3624       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3625       if(!controlRset->tci_PresentInDCI)
3626       {
3627          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3628          return RFAILED;
3629       }
3630       /* TODO */
3631       *(controlRset->tci_PresentInDCI);
3632 #endif
3633
3634       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3635       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3636       if(!controlRSet->pdcch_DMRS_ScramblingID)
3637       {
3638          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3639          return RFAILED;
3640       }
3641       if(pdcchCfg == NULLP)
3642          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3643       else
3644          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3645    }
3646    return ROK;
3647 } /* End BuildControlRSetToAddModList */
3648
3649 /*******************************************************************
3650  *
3651  * @brief Build search space to add/modify list
3652  *
3653  * @details
3654  *
3655  *    Function : BuildSearchSpcToAddModList
3656  *
3657  *    Functionality: Build search space to add/modify list
3658  *
3659  * @params[in]
3660  * @return ROK     - success
3661  *         RFAILED - failure
3662  *
3663  * ****************************************************************/
3664 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3665 {
3666    uint8_t idx;
3667    uint8_t numBytes;
3668    uint8_t byteIdx;
3669    uint8_t bitsUnused;
3670    uint8_t elementCnt;
3671    struct SearchSpace *searchSpc;
3672
3673    if(pdcchCfg == NULLP)
3674       elementCnt = 1;
3675    else
3676       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3677
3678    searchSpcList->list.count = elementCnt;
3679    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3680
3681    searchSpcList->list.array = NULLP;
3682    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3683    if(!searchSpcList->list.array)
3684    {
3685       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3686       return RFAILED;
3687    }
3688
3689    for(idx = 0; idx < elementCnt; idx++)
3690    {
3691       searchSpcList->list.array[idx] = NULLP;
3692       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3693       if(!searchSpcList->list.array[idx])
3694       {
3695          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3696          return RFAILED;
3697       }
3698    }
3699
3700    for(idx = 0; idx < elementCnt; idx++)
3701    {
3702       searchSpc = searchSpcList->list.array[idx];
3703
3704       if(pdcchCfg == NULLP)
3705          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3706       else
3707          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3708
3709       searchSpc->controlResourceSetId = NULLP;
3710       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3711       if(!searchSpc->controlResourceSetId)
3712       {
3713          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3714          return RFAILED;
3715       }
3716       if(pdcchCfg == NULLP)
3717          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3718       else
3719          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3720
3721       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3722       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3723       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3724       {
3725          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3726          return RFAILED;
3727       }
3728       if(pdcchCfg == NULLP)
3729          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3730       else
3731          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3732
3733       searchSpc->duration = NULLP;
3734       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3735       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3736       if(!searchSpc->monitoringSymbolsWithinSlot)
3737       {
3738          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3739          return RFAILED;
3740       }
3741
3742       /* Values taken from reference logs :
3743        * size 2 bytes
3744        * 2 LSBs unsued
3745        * Bit string stores 8000
3746        */
3747       numBytes = 2;
3748       bitsUnused = 2;
3749       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3750       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3751       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3752       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3753       {
3754          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3755          return RFAILED;
3756       }
3757       if(pdcchCfg == NULLP)
3758       {
3759          byteIdx = 0;
3760          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3761          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3762       }
3763       else
3764          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3765       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3766
3767       searchSpc->nrofCandidates = NULLP;
3768       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3769       if(!searchSpc->nrofCandidates)
3770       {
3771          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3772          return RFAILED;
3773       }
3774
3775       if(pdcchCfg == NULLP)
3776       {
3777          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3778          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3779          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3780          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3781          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3782       }
3783       else
3784       {
3785          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3786          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3787          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3788          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3789          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3790       }
3791
3792       searchSpc->searchSpaceType = NULLP;
3793       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3794       if(!searchSpc->searchSpaceType)
3795       {
3796          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3797          return RFAILED;
3798       }
3799       if(pdcchCfg == NULLP)
3800          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3801       else
3802          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3803
3804       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3805       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3806       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3807       {
3808          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3809          return RFAILED;
3810       }
3811       if(pdcchCfg == NULLP)
3812          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3813       else
3814          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3815    }
3816    return ROK;
3817 }/* End BuildSearchSpcToAddModList */
3818
3819 /*******************************************************************
3820  *
3821  * @brief Builds BWP DL dedicated PDCCH config
3822  *
3823  * @details
3824  *
3825  *    Function : BuildBWPDlDedPdcchCfg
3826  *
3827  *    Functionality: Builds BWP DL dedicated PDCCH config
3828  *
3829  * @params[in] struct PDCCH_Config *pdcchCfg
3830  *
3831  * @return ROK     - success
3832  *         RFAILED - failure
3833  *
3834  * ****************************************************************/
3835 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3836 {
3837    pdcchCfg->controlResourceSetToAddModList = NULLP;
3838    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3839    if(!pdcchCfg->controlResourceSetToAddModList)
3840    {
3841       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3842       return RFAILED;
3843    }
3844
3845    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3846    {
3847       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3848       return RFAILED;
3849    }
3850
3851    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3852
3853    pdcchCfg->searchSpacesToAddModList = NULLP;
3854    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3855    if(!pdcchCfg->searchSpacesToAddModList)
3856    {
3857       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3858       return RFAILED;
3859    }
3860
3861    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3862    {
3863       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3864       return RFAILED;
3865    }
3866
3867    pdcchCfg->searchSpacesToReleaseList = NULLP;
3868    pdcchCfg->downlinkPreemption = NULLP;
3869    pdcchCfg->tpc_PUSCH = NULLP;
3870    pdcchCfg->tpc_PUCCH = NULLP;
3871    pdcchCfg->tpc_SRS = NULLP;
3872
3873    return ROK;
3874 }
3875
3876 /*******************************************************************
3877  *
3878  * @brief Builds DMRS DL PDSCH Mapping type A
3879  *
3880  * @details
3881  *
3882  *    Function : BuildDMRSDLPdschMapTypeA
3883  *
3884  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3885  *
3886  * @params[in]
3887  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3888  * @return ROK     - success
3889  *         RFAILED - failure
3890  *
3891  * ****************************************************************/
3892 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3893 {
3894    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3895    dmrsDlCfg->choice.setup = NULLP;
3896    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3897    if(!dmrsDlCfg->choice.setup)
3898    {
3899       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3900       return RFAILED;
3901    }
3902
3903    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3904    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3905    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3906    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3907    {
3908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3909       return RFAILED;
3910    }
3911    if(pdschCfg == NULLP)
3912       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3913    else
3914       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3915
3916    dmrsDlCfg->choice.setup->maxLength = NULLP;
3917    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3918    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3919    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3920
3921    return ROK;
3922 }
3923
3924 /*******************************************************************
3925  *
3926  * @brief Builds TCI states to add/modify list
3927  *
3928  * @details
3929  *
3930  *    Function : BuildTCIStatesToAddModList
3931  *
3932  *    Functionality:Builds TCI states to add/modify list
3933  *
3934  * @params[in]
3935  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3936  *
3937  * @return ROK     - success
3938  *         RFAILED - failure
3939  *
3940  * ****************************************************************/
3941 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3942 {
3943    return ROK;
3944 }
3945
3946 /*******************************************************************
3947  *
3948  * @brief Builds PDSCH time domain allocation list
3949  *
3950  * @details
3951  *
3952  *    Function : BuildPdschTimeDomAllocList
3953  *
3954  *    Functionality: Builds PDSCH time domain allocation list
3955  *
3956  * @params[in]
3957  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3958  *
3959  * @return ROK     - success
3960  *         RFAILED - failure
3961  *
3962  * ****************************************************************/
3963 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
3964 {
3965    uint8_t idx;
3966    uint8_t elementCnt;
3967    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3968
3969    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3970
3971    timeDomAllocList->choice.setup = NULLP;
3972    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3973    if(!timeDomAllocList->choice.setup)
3974    {
3975       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3976       return RFAILED;
3977    }
3978
3979 if(pdschCfg == NULLP)
3980    elementCnt = 2;
3981 else
3982 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
3983    timeDomAllocList->choice.setup->list.count = elementCnt;
3984    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3985
3986    timeDomAllocList->choice.setup->list.array = NULLP;
3987    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
3988    if(!timeDomAllocList->choice.setup->list.array)
3989    {
3990       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3991       return RFAILED;
3992    }
3993
3994    for(idx = 0; idx < elementCnt; idx++)
3995    {
3996       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3997       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3998             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3999       if(!timeDomAllocList->choice.setup->list.array[idx])
4000       {
4001          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4002          return RFAILED;
4003       }
4004    }
4005
4006    if(pdschCfg == NULLP)
4007    {
4008       idx = 0;
4009       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4010       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4011       if(!timeDomAlloc->k0)
4012       {
4013          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4014          return RFAILED;
4015       }
4016       *(timeDomAlloc->k0) = 0;
4017       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4018       timeDomAlloc->startSymbolAndLength = \
4019                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4020
4021       idx++;
4022       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4023       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4024       if(!timeDomAlloc->k0)
4025       {
4026          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4027          return RFAILED;
4028       }
4029       *(timeDomAlloc->k0) = 1;
4030       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4031       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4032    }
4033    else
4034    {
4035       for(idx = 0; idx < elementCnt; idx++)
4036       {
4037          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4038          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4039          if(!timeDomAlloc->k0)
4040          {
4041             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4042             return RFAILED;
4043          }
4044          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4045             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4046          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4047          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4048       }
4049    }
4050
4051    return ROK;
4052 }
4053
4054 /*******************************************************************
4055  *
4056  * @brief Builds PDSCH PRB Bundling type
4057  *
4058  * @details
4059  *
4060  *    Function : BuildPdschPrbBundlingType
4061  *
4062  *    Functionality: Builds PDSCH PRB Bundling type
4063  *
4064  * @params[in]
4065  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4066  *
4067  * @return ROK     - success
4068  *         RFAILED - failure
4069  *
4070  * ****************************************************************/
4071 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4072 {
4073    if(pdschCfg == NULLP)
4074       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4075    else
4076       prbBndlType->present = pdschCfg->bundlingType;
4077
4078    prbBndlType->choice.staticBundling = NULLP;
4079    DU_ALLOC(prbBndlType->choice.staticBundling, \
4080          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4081    if(!prbBndlType->choice.staticBundling)
4082    {
4083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4084       return RFAILED;
4085    }
4086    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4087
4088    return ROK;
4089 }
4090
4091 /*******************************************************************
4092  *
4093  * @brief Builds BWP DL dedicated PDSCH config
4094  *
4095  * @details
4096  *
4097  *    Function : BuildBWPDlDedPdschCfg
4098  *
4099  *    Functionality: Builds BWP DL dedicated PDSCH config
4100  *
4101  * @params[in] struct PDSCH_Config *pdschCfg
4102  *
4103  * @return ROK     - success
4104  *         RFAILED - failure
4105  *
4106  * ****************************************************************/
4107 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4108 {
4109    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4110
4111    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4112    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4113    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4114    {
4115       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4116       return RFAILED;
4117    }
4118
4119    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4120    {
4121       return RFAILED;
4122    }
4123
4124    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4125    pdschCfg->tci_StatesToAddModList = NULLP;
4126    pdschCfg->tci_StatesToReleaseList = NULLP;
4127    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4128 #if 0
4129    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4130    if(!pdschCfg->tci_StatesToAddModList)
4131    {
4132       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4133       return RFAILED;
4134    }
4135    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4136    {
4137       return RFAILED;
4138    }
4139 #endif
4140
4141 if(pdschCfgDb == NULLP)
4142    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4143 else
4144 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4145
4146    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4147    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4148    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4149    {
4150       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4151       return RFAILED;
4152    }
4153    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4154    {
4155       return RFAILED;
4156    }
4157
4158    pdschCfg->pdsch_AggregationFactor = NULLP;
4159    pdschCfg->rateMatchPatternToAddModList = NULLP;
4160    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4161    pdschCfg->rateMatchPatternGroup1 = NULLP;
4162    pdschCfg->rateMatchPatternGroup2 = NULLP;
4163    if(pdschCfgDb == NULLP)
4164       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4165    else
4166       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4167    pdschCfg->mcs_Table = NULLP;
4168
4169    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4170    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4171    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4172    {
4173       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4174       return RFAILED;
4175    }
4176    if(pdschCfgDb == NULLP)
4177       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4178    else
4179       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4180
4181    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4182    {
4183       return RFAILED;
4184    }
4185
4186    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4187    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4188    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4189    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4190    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4191    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4192    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4193
4194    return ROK;
4195 }
4196
4197 /*******************************************************************
4198  *
4199  * @brief Builds intitial DL BWP
4200  * @details
4201  *
4202  *    Function : BuildInitialDlBWP
4203  *
4204  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4205  *
4206  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4207  *
4208  * @return ROK     - success
4209  *         RFAILED - failure
4210  *
4211  * ****************************************************************/
4212 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4213 {
4214    PdcchConfig *pdcchCfg = NULLP;
4215    PdschConfig *pdschCfg = NULLP;
4216
4217    if(initiDlBwp)
4218    {
4219       if(initiDlBwp->pdcchPresent)
4220          pdcchCfg = &initiDlBwp->pdcchCfg;
4221       if(initiDlBwp->pdschPresent)
4222          pdschCfg = &initiDlBwp->pdschCfg;
4223    }
4224
4225    dlBwp->pdcch_Config = NULLP;
4226    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4227    if(!dlBwp->pdcch_Config)
4228    {
4229       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4230       return RFAILED;
4231    }
4232    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4233
4234    dlBwp->pdcch_Config->choice.setup = NULLP;
4235    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4236    if(!dlBwp->pdcch_Config->choice.setup)
4237    {
4238       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4239       return RFAILED;
4240    }
4241    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4242    {
4243       return RFAILED;
4244    }
4245
4246    dlBwp->pdsch_Config = NULLP;
4247    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4248    if(!dlBwp->pdsch_Config)
4249    {
4250       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4251       return RFAILED;
4252    }
4253    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4254
4255    dlBwp->pdsch_Config->choice.setup = NULLP;
4256    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4257    if(!dlBwp->pdsch_Config->choice.setup)
4258    {
4259       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4260       return RFAILED;
4261    }
4262
4263    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4264    {
4265       return RFAILED;
4266    }
4267
4268    dlBwp->sps_Config = NULLP;
4269    dlBwp->radioLinkMonitoringConfig = NULLP;
4270    return ROK;
4271 }
4272
4273 /*******************************************************************
4274  *
4275  * @brief Builds DMRS UL Pusch Mapping type A
4276  *
4277  * @details
4278  *
4279  *    Function : BuildDMRSULPuschMapTypeA
4280  *
4281  *    Functionality: Builds DMRS UL Pusch Mapping type A
4282  *
4283  * @params[in]
4284  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4285  * @return ROK     - success
4286  *         RFAILED - failure
4287  *
4288  * ****************************************************************/
4289 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4290 {
4291    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4292    dmrsUlCfg->choice.setup= NULLP;
4293    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4294    if(!dmrsUlCfg->choice.setup)
4295    {
4296       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4297       return RFAILED;
4298    }
4299
4300    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4301    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4302    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4303    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4304    {
4305       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4306       return RFAILED;
4307    }
4308    if(ulDmrsCfgDb == NULLP)
4309       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4310    else
4311       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4312
4313    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4314    dmrsUlCfg->choice.setup->maxLength = NULLP;
4315    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4316    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4317    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4318    {
4319       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4320       return RFAILED;
4321    }
4322
4323    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4324    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4325          sizeof(long));
4326    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4327    {
4328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4329       return RFAILED;
4330    }
4331    if(ulDmrsCfgDb == NULLP)
4332       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4333    else
4334       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4335
4336    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4337    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4338    return ROK;
4339 }
4340
4341 /*******************************************************************
4342  *
4343  * @brief Build PUSCH time domain allocation list
4344  *
4345  * @details
4346  *
4347  *    Function : BuildPuschTimeDomAllocList
4348  *
4349  *    Functionality: Build PUSCH time domain allocation list
4350  *
4351  * @params[in]
4352  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4353  *
4354  * @return ROK     - success
4355  *         RFAILED - failure
4356  *
4357  * ****************************************************************/
4358 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4359 {
4360    uint8_t idx;
4361    uint8_t elementCnt;
4362    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4363
4364    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4365    timeDomAllocList->choice.setup = NULLP;
4366    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4367    if(!timeDomAllocList->choice.setup)
4368    {
4369       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4370       return RFAILED;
4371    }
4372
4373    if(puschCfgDb == NULLP)
4374       elementCnt = 2;
4375    else
4376       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4377
4378    timeDomAllocList->choice.setup->list.count = elementCnt;
4379    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4380    timeDomAllocList->choice.setup->list.array = NULLP;
4381    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4382    if(!timeDomAllocList->choice.setup->list.array)
4383    {
4384       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4385       return RFAILED;
4386    }
4387
4388    for(idx = 0; idx < elementCnt; idx++)
4389    {
4390       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4391       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4392       if(!timeDomAllocList->choice.setup->list.array[idx])
4393       {
4394          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4395          return RFAILED;
4396       }
4397    }
4398
4399    for(idx = 0; idx < elementCnt; idx++)
4400    {
4401       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4402       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4403       if(!timeDomAlloc->k2)
4404       {
4405          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4406          return RFAILED;
4407       }
4408       if(puschCfgDb == NULLP)
4409       {
4410          if(idx == 0)
4411             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4412          else if(idx == 1)
4413             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4414
4415          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4416          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4417       }
4418       else
4419       {
4420          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4421          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4422          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4423       }
4424    }
4425
4426    return ROK;
4427 }
4428
4429 /*******************************************************************
4430  *
4431  * @brief Builds BWP UL dedicated PUSCH Config
4432  *
4433  * @details
4434  *
4435  *    Function : BuildBWPUlDedPuschCfg
4436  *
4437  *    Functionality:
4438  *      Builds BWP UL dedicated PUSCH Config
4439  *
4440  * @params[in] : PUSCH_Config_t *puschCfg
4441  *
4442  * @return ROK     - success
4443  *         RFAILED - failure
4444  *
4445  * ****************************************************************/
4446 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4447 {
4448    DmrsUlCfg *ulDmrsCfg = NULLP;
4449
4450    if(puschCfgDb)
4451       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4452
4453    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4454    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4455    if(!puschCfg->dataScramblingIdentityPUSCH)
4456    {
4457       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4458       return RFAILED;
4459    }
4460    if(puschCfgDb == NULLP)
4461       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4462    else
4463       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4464
4465    puschCfg->txConfig = NULLP;
4466    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4467    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4468    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4469    {
4470       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4471       return RFAILED;
4472    }
4473
4474    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4475    {
4476       return RFAILED;
4477    }
4478
4479    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4480    puschCfg->pusch_PowerControl = NULLP;
4481    puschCfg->frequencyHopping = NULLP;
4482    puschCfg->frequencyHoppingOffsetLists = NULLP;
4483
4484    if(puschCfgDb == NULLP)
4485       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4486    else
4487       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4488
4489    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4490    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4491    if(!puschCfg->pusch_TimeDomainAllocationList)
4492    {
4493       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4494       return RFAILED;
4495    }
4496
4497    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4498    {
4499       return RFAILED;
4500    }
4501
4502    puschCfg->pusch_AggregationFactor = NULLP;
4503    puschCfg->mcs_Table = NULLP;
4504    puschCfg->mcs_TableTransformPrecoder = NULLP;
4505    puschCfg->transformPrecoder = NULLP;
4506    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4507    if(!puschCfg->transformPrecoder)
4508    {
4509       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4510       return RFAILED;
4511    }
4512    if(puschCfgDb == NULLP)
4513       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4514    else
4515       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4516
4517    puschCfg->codebookSubset = NULLP;
4518    puschCfg->maxRank = NULLP;
4519    puschCfg->rbg_Size = NULLP;
4520    puschCfg->uci_OnPUSCH = NULLP;
4521    puschCfg->tp_pi2BPSK = NULLP;
4522
4523    return ROK;
4524 }
4525
4526 /*******************************************************************
4527  *
4528  * @brief Builds PUCCH resource set add/modify list
4529  *
4530  * @details
4531  *
4532  *    Function : BuildPucchRsrcSetAddModList
4533  *
4534  *    Functionality:
4535  *      Builds PUCCH resource set add/modify list
4536  *
4537  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4538  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4539  *
4540  * @return ROK     - success
4541  *         RFAILED - failure
4542  *
4543  * ****************************************************************/
4544 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4545    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4546 {
4547    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4548    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4549
4550    if(rsrcSetCfgDb == NULLP)
4551       elementCnt = 1;
4552    else
4553       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4554
4555    resourceSetToAddModList->list.count = elementCnt;
4556    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4557    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4558    if(resourceSetToAddModList->list.array == NULLP)
4559    {
4560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4561       return RFAILED;
4562    }
4563    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4564    {
4565       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4566       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4567       {
4568          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4569          return RFAILED;
4570       }
4571    }
4572
4573    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4574    {
4575       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4576
4577       /* Resource set Id */
4578       if(rsrcSetCfgDb == NULLP)
4579          rsrcSet->pucch_ResourceSetId = 1;
4580       else
4581          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4582
4583       /* Resource list of a resource set */
4584       if(rsrcSetCfgDb == NULLP)
4585          elementCnt = 1;
4586       else
4587          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4588       rsrcSet->resourceList.list.count = elementCnt;
4589       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4590       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4591       if(rsrcSet->resourceList.list.array == NULLP)
4592       {
4593          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4594          return RFAILED;
4595       }
4596
4597       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4598       {
4599          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4600          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4601          {
4602             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4603             return RFAILED;
4604          }
4605       }
4606       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4607       {
4608          if(rsrcSetCfgDb == NULLP)
4609             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4610          else
4611             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4612       }
4613
4614       /* Max payload size (minus 1) in a Resource set */
4615       rsrcSet->maxPayloadMinus1 = NULLP;
4616       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4617       {
4618          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4619          if(rsrcSet->maxPayloadMinus1 == NULLP)
4620          {
4621             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4622             return RFAILED;
4623          }
4624          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4625       }
4626    }
4627    return ROK;
4628 }
4629
4630 /*******************************************************************
4631  *
4632  * @brief Builds PUCCH resource add/modify list
4633  *
4634  * @details
4635  *
4636  *    Function : BuildPucchRsrcAdddModList
4637  *
4638  *    Functionality:
4639  *      Builds PUCCH resource add/modify list
4640  *
4641  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4642  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4643  *
4644  * @return ROK     - success
4645  *         RFAILED - failure
4646  *
4647  * ****************************************************************/
4648 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4649 {
4650    uint8_t elementCnt = 0, rsrcIdx = 0;
4651    PUCCH_Resource_t *rsrc = NULLP;
4652
4653    if(rsrcCfgDb == NULLP)
4654       elementCnt = 1;
4655    else
4656       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4657    resourceToAddModList->list.count = elementCnt;
4658    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4659    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4660    if(resourceToAddModList->list.array == NULLP)
4661    {
4662       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4663       return RFAILED;
4664    }
4665    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4666    {
4667       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4668       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4669       {
4670          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4671          return RFAILED;
4672       }
4673    }
4674
4675    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4676    {
4677       rsrc = resourceToAddModList->list.array[rsrcIdx];
4678
4679       if(rsrcCfgDb == NULLP)
4680       {
4681          rsrc->pucch_ResourceId = 1;
4682          rsrc->startingPRB = 0;
4683          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4684          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4685          if(rsrc->format.choice.format1 == NULLP)
4686          {
4687             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4688             return RFAILED;
4689          }
4690          rsrc->format.choice.format1->initialCyclicShift = 0;
4691          rsrc->format.choice.format1->nrofSymbols = 4;
4692          rsrc->format.choice.format1->startingSymbolIndex = 0;
4693          rsrc->format.choice.format1->timeDomainOCC = 0;
4694       }
4695       else
4696       {
4697          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4698          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4699          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4700          {
4701             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4702             if(rsrc->intraSlotFrequencyHopping == NULLP)
4703             {
4704                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4705                return RFAILED;
4706             }
4707             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4708          }
4709          else
4710             rsrc->intraSlotFrequencyHopping = NULLP;
4711
4712          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4713          {
4714             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4715             if(rsrc->secondHopPRB == NULLP)
4716             {
4717                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4718                return RFAILED;
4719             }
4720             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4721          }
4722          else
4723             rsrc->secondHopPRB = NULLP;
4724          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4725
4726          switch(rsrc->format.present)
4727          {
4728             case PUCCH_Resource__format_PR_NOTHING:
4729                break;
4730             case PUCCH_Resource__format_PR_format0:
4731                {
4732                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4733                   if(rsrc->format.choice.format0 == NULLP)
4734                   {
4735                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4736                      return RFAILED;
4737                   }
4738                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4739                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4740                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4741                   break;
4742                }
4743
4744             case PUCCH_Resource__format_PR_format1:
4745                {
4746                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4747                   if(rsrc->format.choice.format1 == NULLP)
4748                   {
4749                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4750                      return RFAILED;
4751                   }
4752                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4753                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4754                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4755                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4756                   break;
4757                }
4758
4759             case PUCCH_Resource__format_PR_format2:
4760                {
4761                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4762                   if(rsrc->format.choice.format2 == NULLP)
4763                   {
4764                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4765                      return RFAILED;
4766                   }
4767                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4768                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4769                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4770                   break;
4771                }
4772
4773             case PUCCH_Resource__format_PR_format3:
4774                {
4775                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4776                   if(rsrc->format.choice.format3 == NULLP)
4777                   {
4778                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4779                      return RFAILED;
4780                   }
4781                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4782                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4783                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4784                   break;
4785                }
4786
4787             case PUCCH_Resource__format_PR_format4:
4788                {
4789                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4790                   if(rsrc->format.choice.format4 == NULLP)
4791                   {
4792                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4793                      return RFAILED;
4794                   }
4795                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4796                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4797                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4798                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4799                   break;
4800                }
4801          }
4802       }
4803    }
4804    return ROK;
4805 }
4806
4807 /*******************************************************************
4808  *
4809  * @brief Builds PUCCH format  config
4810  *
4811  * @details
4812  *
4813  *    Function : BuildPucchFormat
4814  *
4815  *    Functionality: Builds PUCCH format  config
4816  *
4817  * @params[in] : PucchFormatCfg *formatDb
4818  *               PUCCH_FormatConfig_t *format
4819  *
4820  * @return ROK     - success
4821  *         RFAILED - failure
4822  *
4823  * ****************************************************************/
4824 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4825 {
4826    /* Inter Slot Fequency hopping */
4827    format->interslotFrequencyHopping = NULLP;
4828    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4829    {
4830       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4831       if(format->interslotFrequencyHopping)
4832       {
4833          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4834          return RFAILED;
4835       }
4836       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4837    }
4838
4839    /* Additional DMRS */
4840    format->additionalDMRS = NULLP;
4841    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4842    {
4843       DU_ALLOC(format->additionalDMRS, sizeof(long));
4844       if(format->additionalDMRS)
4845       {
4846          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4847          return RFAILED;
4848       }
4849       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4850    }
4851
4852     /* Maximum code rate */
4853    format->maxCodeRate = NULLP;
4854    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4855    {
4856       DU_ALLOC(format->maxCodeRate, sizeof(long));
4857       if(format->maxCodeRate)
4858       {
4859          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4860          return RFAILED;
4861       }
4862       *(format->maxCodeRate) = formatDb->maxCodeRate;
4863    }
4864
4865    /* Number of slots */
4866    format->nrofSlots = NULLP;
4867    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4868    {
4869       DU_ALLOC(format->nrofSlots, sizeof(long));
4870       if(format->nrofSlots == NULLP)
4871       {
4872          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4873          return RFAILED;
4874       }
4875       if(formatDb == NULLP)
4876          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4877       else
4878          *(format->nrofSlots) = formatDb->numSlots;
4879    }
4880
4881    /* Pi2BPSK*/
4882    format->pi2BPSK = NULLP;
4883    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4884    {
4885       DU_ALLOC(format->pi2BPSK, sizeof(long));
4886       if(format->pi2BPSK)
4887       {
4888          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4889          return RFAILED;
4890       }
4891       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4892    }
4893
4894    /* Simultaneous HARQ ACK and CSI */
4895    format->simultaneousHARQ_ACK_CSI = NULLP;
4896    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4897    {
4898       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4899       if(format->simultaneousHARQ_ACK_CSI)
4900       {
4901          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4902          return RFAILED;
4903       }
4904       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4905    }
4906
4907    return ROK;
4908 }
4909
4910
4911 /*******************************************************************
4912  *
4913  * @brief Builds PUCCH scheduling request list
4914  *
4915  * @details
4916  *
4917  *    Function : BuildPucchSchReqAddModList
4918  *
4919  *    Functionality:
4920  *      Builds PUCCH scheduling request list
4921  *
4922  * @params[in] : PucchSchedReqCfg *schReqDb
4923  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4924  *
4925  * @return ROK     - success
4926  *         RFAILED - failure
4927  *
4928  * ****************************************************************/
4929 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4930    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4931 {
4932    uint8_t elementCnt = 0, schReqIdx = 0;
4933    SchedulingRequestResourceConfig_t *schReqRsrc;
4934
4935    elementCnt = schReqDb->schedAddModListCount;
4936    schReqRsrcToAddModList->list.count = elementCnt;
4937    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4938
4939    schReqRsrcToAddModList->list.array = NULLP;
4940    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4941    if(schReqRsrcToAddModList->list.array == NULLP)
4942    {
4943       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4944       return RFAILED;
4945    }
4946
4947    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4948    {
4949       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4950       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4951       {
4952          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4953          return RFAILED;
4954       }
4955    }
4956
4957    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4958    {
4959       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
4960       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
4961       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
4962
4963       if(schReqDb->schedAddModList[schReqIdx].periodicity)
4964       {
4965          schReqRsrc->periodicityAndOffset = NULLP;
4966          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
4967          if(schReqRsrc->periodicityAndOffset == NULLP)
4968          {
4969             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4970             return RFAILED;
4971          }
4972
4973          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
4974          switch(schReqRsrc->periodicityAndOffset->present)
4975          {
4976             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
4977                break;
4978             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
4979                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
4980                break;
4981             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
4982                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
4983                break;
4984             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
4985                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
4986                break;
4987             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
4988                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
4989                break;
4990             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
4991                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
4992                break;
4993             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
4994                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
4995                break;
4996             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
4997                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
4998                break;
4999             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
5000                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
5001                break;
5002             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
5003                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
5004                break;
5005             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
5006                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5007                break;
5008             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5009                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5010                break;
5011             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5012                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5013                break;
5014             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5015                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5016                break;
5017             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5018                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5019                break;
5020             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5021                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5022                break;
5023          }
5024       }
5025
5026       if(schReqDb->schedAddModList[schReqIdx].resrc)
5027       {
5028          schReqRsrc->resource = NULLP;
5029          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5030          if(schReqRsrc->resource == NULLP)
5031          {
5032             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5033             return RFAILED;
5034          }
5035          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5036
5037       }
5038    }
5039    return ROK;
5040 }
5041
5042 /*******************************************************************
5043  *
5044  * @brief Builds PUCCH multi csi resource list
5045  *
5046  * @details
5047  *
5048  *    Function : BuildPucchMultiCsiRsrcList
5049  *
5050  *    Functionality:
5051  *      Builds PUCCH multi csi resource list
5052  *
5053  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5054  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5055  *
5056  * @return ROK     - success
5057  *         RFAILED - failure
5058  *
5059  * ****************************************************************/
5060 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5061 {
5062    uint8_t elementCnt = 0, rsrcIdx = 0;
5063
5064    elementCnt = multiCsiDb->multiCsiResrcListCount;
5065    multiCsiRsrcList->list.count = elementCnt;
5066    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5067    multiCsiRsrcList->list.array = NULLP;
5068    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5069    if(multiCsiRsrcList->list.array == NULLP)
5070    {
5071       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5072       return RFAILED;
5073    }
5074
5075    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5076    {
5077       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5078       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5079       {
5080          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5081          return RFAILED;
5082       }
5083    }
5084
5085    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5086    {
5087       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5088    }
5089    return ROK;
5090 }
5091
5092 /*******************************************************************
5093  *
5094  * @brief Builds DL data -to- Ul Ack list
5095  *
5096  * @details
5097  *
5098  *    Function : BuildDlDataToUlAckList
5099  *
5100  *    Functionality: Builds DL data -to- Ul Ack list
5101  *
5102  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5103  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5104  *
5105  * @return ROK     - success
5106  *         RFAILED - failure
5107  *
5108  * ****************************************************************/
5109 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5110 {
5111    uint8_t elementCnt = 0, arrIdx = 0;
5112
5113    if(dlDataToUlAckDb == NULLP)
5114       elementCnt = 2;
5115    else
5116       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5117
5118    dlDataToUlACKList->list.count = elementCnt;
5119    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5120    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5121    if(dlDataToUlACKList->list.array == NULLP)
5122    {
5123       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5124       return RFAILED;
5125    }
5126
5127    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5128    {
5129       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5130       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5131       {
5132          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5133          return RFAILED;
5134       }
5135    }
5136
5137    if(dlDataToUlAckDb == NULLP)
5138    {
5139       arrIdx = 0;
5140       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5141       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5142    }
5143    else
5144    {
5145       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5146       {
5147          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5148       }
5149    }
5150    return ROK;
5151 }
5152
5153 /*******************************************************************
5154  *
5155  * @brief Builds BWP UL dedicated PUCCH Config
5156  *
5157  * @details
5158  *
5159  *    Function : BuildBWPUlDedPucchCfg
5160  *
5161  *    Functionality:
5162  *      Builds BWP UL dedicated PUCCH Config
5163  *
5164  * @params[in] : PUCCH_Config_t *pucchCfg
5165  *
5166  * @return ROK     - success
5167  *         RFAILED - failure
5168  *
5169  * ****************************************************************/
5170 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5171 {
5172    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5173    PucchResrcCfg *rsrcCfgDb = NULLP;
5174    PucchFormatCfg *format1Db = NULLP;
5175    PucchFormatCfg *format2Db = NULLP;
5176    PucchFormatCfg *format3Db = NULLP;
5177    PucchFormatCfg *format4Db = NULLP;
5178    PucchSchedReqCfg *schReqDb = NULLP;
5179    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5180    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5181
5182    if(pucchCfgDb)
5183    {
5184       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5185       rsrcCfgDb = pucchCfgDb->resrc;
5186       format1Db = pucchCfgDb->format1;
5187       format2Db = pucchCfgDb->format2;
5188       format3Db = pucchCfgDb->format3;
5189       format4Db = pucchCfgDb->format4;
5190       schReqDb = pucchCfgDb->schedReq;
5191       multiCsiDb = pucchCfgDb->multiCsiCfg;
5192       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5193    }
5194
5195    /* RESOURCE SET */
5196    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5197    if(pucchCfg->resourceSetToAddModList == NULL)
5198    {
5199       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5200       return RFAILED;
5201    }
5202
5203    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5204    {
5205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5206       return RFAILED;
5207    }
5208
5209    /* PUCCH RESOURCE */
5210    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5211    if(pucchCfg->resourceToAddModList == NULLP)
5212    {
5213       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5214       return RFAILED;
5215    }
5216
5217    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5218    {
5219       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5220       return RFAILED;
5221    }
5222
5223    /* PUCCH Format 1 */
5224    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5225    if(pucchCfg->format1 == NULLP)
5226    {
5227       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5228       return RFAILED;
5229    }
5230
5231    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5232    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5233    if(pucchCfg->format1->choice.setup == NULLP)
5234    {
5235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5236       return RFAILED;
5237    }
5238
5239    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5240    {
5241       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5242       return RFAILED;
5243    }
5244
5245    /* PUCCH Format 2 */
5246    if(format2Db)
5247    {
5248       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5249       if(pucchCfg->format2 == NULLP)
5250       {
5251          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5252          return RFAILED;
5253       }
5254
5255       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5256       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5257       if(pucchCfg->format2->choice.setup == NULLP)
5258       {
5259          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5260          return RFAILED;
5261       }
5262
5263       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5264       {
5265          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5266          return RFAILED;
5267       }
5268    }
5269
5270    /* PUCCH Format 3 */
5271    if(format3Db)
5272    {
5273       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5274       if(pucchCfg->format3 == NULLP)
5275       {
5276          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5277          return RFAILED;
5278       }
5279
5280       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5281       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5282       if(pucchCfg->format3->choice.setup == NULLP)
5283       {
5284          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5285          return RFAILED;
5286       }
5287
5288       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5289       {
5290          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5291          return RFAILED;
5292       }
5293    }
5294
5295    /* PUCCH Format 4 */
5296    if(format4Db)
5297    {
5298       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5299       if(pucchCfg->format4 == NULLP)
5300       {
5301          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5302          return RFAILED;
5303       }
5304
5305       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5306       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5307       if(pucchCfg->format4->choice.setup == NULLP)
5308       {
5309          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5310          return RFAILED;
5311       }
5312
5313       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5314       {
5315          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5316          return RFAILED;
5317       }
5318    }
5319
5320    /* Scheduling Request */
5321    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5322    {
5323       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5324       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5325       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5326       {
5327          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5328          return RFAILED;
5329       }
5330
5331       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5332       {
5333          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5334          return RFAILED;
5335       }
5336    }
5337
5338    /* Multi CSI */
5339    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5340    {
5341       pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP;
5342       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5343       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5344       {
5345          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5346          return RFAILED;
5347       }
5348
5349       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5350       {
5351          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5352          return RFAILED;
5353       }
5354    }
5355
5356    /* DL DATA TO UL ACK */
5357    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5358    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5359    {
5360       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5361       return RFAILED;
5362    }
5363
5364    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5365    {
5366       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5367       return RFAILED;
5368    }
5369
5370    /* TODO : spatial relation info add/mod list and power control*/
5371
5372    return ROK;
5373 }
5374
5375 /*******************************************************************
5376  *
5377  * @brief Fills SRS resource to add/modify list
5378  *
5379  * @details
5380  *
5381  *    Function : BuildSrsRsrcAddModList
5382  *
5383  *    Functionality: Fills SRS resource to add/modify list
5384  *
5385  * @params[in]
5386  * @return ROK     - success
5387  *         RFAILED - failure
5388  *
5389  * ****************************************************************/
5390 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5391 {
5392    uint8_t   elementCnt;
5393    uint8_t   rsrcIdx;
5394
5395    elementCnt = 1;
5396    resourceList->list.count = elementCnt;
5397    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5398    resourceList->list.array = NULLP;
5399    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5400    if(!resourceList->list.array)
5401    {
5402       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5403       return RFAILED;
5404    }
5405
5406    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5407    {
5408       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5409       if(!resourceList->list.array[rsrcIdx])
5410       {
5411          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5412          return RFAILED;
5413       }
5414    }
5415
5416    rsrcIdx = 0;
5417    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5418    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5419    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5420
5421    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5422    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5423          sizeof(struct SRS_Resource__transmissionComb__n2));
5424    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5425    {
5426       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5427       return RFAILED;
5428    }
5429    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5430       = SRS_COMB_OFFSET_N2;
5431    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5432       = SRS_CYCLIC_SHIFT_N2;
5433
5434    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5435                                                                       PUSCH_START_SYMBOL;
5436    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5437                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5438    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5439                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5440
5441    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5442    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5443    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5444    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5445    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5446    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5447                                                                SRS_Resource__groupOrSequenceHopping_neither;
5448
5449    /* Setting resource type to aperiodic for intergration purposes */
5450    resourceList->list.array[rsrcIdx]->resourceType.present = \
5451                                                              SRS_Resource__resourceType_PR_aperiodic;
5452    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5453    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5454          sizeof(struct SRS_Resource__resourceType__aperiodic));
5455    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5456    {
5457       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5458       return RFAILED;
5459    }
5460    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5461
5462    return ROK;
5463 }
5464
5465 /*******************************************************************
5466  *
5467  * @brief Build SRS resource set Add/mod list
5468  *
5469  * @details
5470  *
5471  *    Function : BuildSrsRsrcSetAddModList
5472  *
5473  *    Functionality: Build SRS resource set Add/mod list
5474  *
5475  * @params[in]
5476  * @return ROK     - success
5477  *         RFAILED - failure
5478  *
5479  * ****************************************************************/
5480    uint8_t BuildSrsRsrcSetAddModList
5481 (
5482  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5483  )
5484 {
5485    uint8_t  elementCnt;
5486    uint8_t  rSetIdx;
5487    uint8_t  rsrcIdx;
5488    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5489
5490    elementCnt = 1;
5491    rsrcSetList->list.count = elementCnt;
5492    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5493    rsrcSetList->list.array = NULLP;
5494    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5495    if(!rsrcSetList->list.array)
5496    {
5497       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5498       return RFAILED;
5499    }
5500
5501    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5502    {
5503       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5504       if(!rsrcSetList->list.array[rSetIdx])
5505       {
5506          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5507          return RFAILED;
5508       }
5509    }
5510
5511    rSetIdx = 0;
5512    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5513
5514    /* Fill Resource Id list in resource set */
5515    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5516    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5517          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5518    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5519    {
5520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5521       return RFAILED;
5522    }
5523
5524    elementCnt = 1;
5525    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5526    rsrcIdList->list.count = elementCnt;
5527    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5528    rsrcIdList->list.array = NULLP;
5529    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5530    if(!rsrcIdList->list.array)
5531    {
5532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5533       return RFAILED;
5534    }
5535
5536    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5537    {
5538       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5539       if(!rsrcIdList->list.array[rsrcIdx])
5540       {
5541          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5542          return RFAILED;
5543       }
5544    }
5545
5546    rsrcIdx = 0;
5547    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5548
5549    /* Fill resource type */
5550    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5551                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5552
5553    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5554    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5555          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5556    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5557    {
5558       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5559       return RFAILED;
5560    }
5561    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5562       = APERIODIC_SRS_RESRC_TRIGGER;
5563
5564    /* TODO : Fill values for below IEs as expected by Viavi */
5565    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5566    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5567
5568
5569    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5570    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5571    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5572    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5573    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5574
5575    return ROK;
5576 }
5577
5578 /*******************************************************************
5579  *
5580  * @brief Builds BWP UL dedicated SRS Config
5581  *
5582  * @details
5583  *
5584  *    Function : BuildBWPUlDedSrsCfg
5585  *
5586  *    Functionality: Builds BWP UL dedicated SRS Config
5587  *
5588  * @params[in] SRS Config
5589  * @return ROK     - success
5590  *         RFAILED - failure
5591  *
5592  * ****************************************************************/
5593 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5594 {
5595    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5596    srsCfg->srs_ResourceSetToAddModList = NULLP;
5597    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5598          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5599    if(!srsCfg->srs_ResourceSetToAddModList)
5600    {
5601       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5602       return RFAILED;
5603    }
5604    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5605    {
5606       return RFAILED;
5607    }
5608
5609    srsCfg->srs_ResourceToReleaseList = NULLP;
5610
5611    /* Resource to Add/Modify list */
5612    srsCfg->srs_ResourceToAddModList = NULLP;
5613    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5614          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5615    if(!srsCfg->srs_ResourceToAddModList)
5616    {
5617       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5618       return RFAILED;
5619    }
5620
5621    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5622    {
5623       return RFAILED;
5624    }
5625
5626    srsCfg->tpc_Accumulation = NULLP;
5627
5628    return ROK;
5629 }
5630
5631
5632
5633 /*******************************************************************
5634  *
5635  * @brief Builds Pusch Serving cell Config
5636  *
5637  * @details
5638  *
5639  *    Function : BuildPuschSrvCellCfg
5640  *
5641  *    Functionality: Builds Pusch Serving cell Config
5642  *
5643  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5644  *
5645  * @return ROK     - success
5646  *         RFAILED - failure
5647  *
5648  * ****************************************************************/
5649 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5650 {
5651    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5652    puschCfg->choice.setup = NULLP;
5653    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5654    if(!puschCfg->choice.setup)
5655    {
5656       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5657       return RFAILED;
5658    }
5659
5660    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5661    puschCfg->choice.setup->rateMatching = NULLP;
5662    puschCfg->choice.setup->xOverhead = NULLP;
5663    puschCfg->choice.setup->ext1 = NULLP;
5664    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5665    if(!puschCfg->choice.setup->ext1)
5666    {
5667       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5668       return RFAILED;
5669    }
5670
5671    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5672    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5673    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5674    {
5675       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5676       return RFAILED;
5677    }
5678    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5679
5680    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5681    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5682    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5683    {
5684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5685       return RFAILED;
5686    }
5687    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5688    return ROK;
5689 }
5690
5691 /*******************************************************************
5692  *
5693  * @brief Builds inital UL BWP
5694  *
5695  * @details
5696  *
5697  *    Function : BuildInitialUlBWP
5698  *
5699  *    Functionality: Builds initial UL BWP
5700  *
5701  * @params[in] BWP_UplinkDedicated_t *ulBwp
5702  * @return ROK     - success
5703  *         RFAILED - failure
5704  *
5705  * ****************************************************************/
5706 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5707 {
5708    PucchCfg *pucchCfg = NULLP;
5709    PuschCfg *puschCfg = NULLP;
5710
5711    if(initUlBwp)
5712    {
5713       if(initUlBwp->pucchPresent)
5714          pucchCfg = &initUlBwp->pucchCfg;
5715       if(initUlBwp->puschPresent)
5716          puschCfg = &initUlBwp->puschCfg;
5717    }
5718
5719    ulBwp->pucch_Config = NULLP;
5720    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5721    if(!ulBwp->pucch_Config)
5722    {
5723       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5724       return RFAILED;
5725    }
5726
5727    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5728    ulBwp->pucch_Config->choice.setup = NULLP;
5729    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5730    if(!ulBwp->pucch_Config->choice.setup)
5731    {
5732       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5733       return RFAILED;
5734    }
5735
5736    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5737    {
5738       return RFAILED;
5739    }
5740
5741    /* Fill BWP UL dedicated PUSCH config */
5742    ulBwp->pusch_Config = NULLP;
5743    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5744    if(!ulBwp->pusch_Config)
5745    {
5746       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5747       return RFAILED;
5748    }
5749
5750    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5751    ulBwp->pusch_Config->choice.setup = NULLP;
5752    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5753    if(!ulBwp->pusch_Config->choice.setup)
5754    {
5755       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5756       return RFAILED;
5757    }
5758
5759    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5760    {
5761       return RFAILED;
5762    }
5763
5764    ulBwp->configuredGrantConfig = NULLP;
5765
5766    /* Fill BPW UL dedicated SRS config */
5767    ulBwp->srs_Config = NULLP;
5768    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5769    if(!ulBwp->srs_Config)
5770    {
5771       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5772       return RFAILED;
5773    }
5774
5775    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5776    ulBwp->srs_Config->choice.setup = NULLP;
5777    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5778    if(!ulBwp->srs_Config->choice.setup)
5779    {
5780       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5781       return RFAILED;
5782    }
5783
5784    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5785    {
5786       return RFAILED;
5787    }
5788
5789    ulBwp->beamFailureRecoveryConfig = NULLP;
5790
5791    return ROK;
5792 }
5793
5794 /*******************************************************************
5795  *
5796  * @brief Builds UL config
5797  * @details
5798  *
5799  *    Function : BuildUlCfg
5800  *
5801  *    Functionality: Builds UL config in spCellCfgDed
5802  *
5803  * @params[in] UplinkConfig_t *ulCfg
5804  *
5805  * @return ROK     - success
5806  *         RFAILED - failure
5807  *
5808  * ****************************************************************/
5809 uint8_t BuildUlCfg(ServCellCfgInfo *servCellCfg, UplinkConfig_t *ulCfg)
5810 {
5811    InitialUlBwp *initUlBwp = NULLP;
5812
5813    if(servCellCfg)
5814    {
5815       initUlBwp = &servCellCfg->initUlBwp;
5816    }
5817
5818    ulCfg->initialUplinkBWP = NULLP;
5819    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5820    if(!ulCfg->initialUplinkBWP)
5821    {
5822       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5823       return RFAILED;
5824    }
5825
5826    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5827    {
5828       return RFAILED;
5829    }
5830
5831    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5832    ulCfg->uplinkBWP_ToAddModList = NULLP;
5833    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5834    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5835    if(!ulCfg->firstActiveUplinkBWP_Id)
5836    {
5837       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5838       return RFAILED;
5839    }
5840    if(servCellCfg == NULLP)
5841       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5842    else
5843       *(ulCfg->firstActiveUplinkBWP_Id) = servCellCfg->firstActvUlBwpId;
5844
5845    ulCfg->pusch_ServingCellConfig = NULLP;
5846    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5847    if(!ulCfg->pusch_ServingCellConfig)
5848    {
5849       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5850       return RFAILED;
5851    }
5852
5853    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5854    {
5855       return RFAILED;
5856    }
5857
5858    ulCfg->carrierSwitching = NULLP;
5859    ulCfg->ext1 = NULLP;
5860    return ROK;
5861 }
5862
5863 /*******************************************************************
5864  *
5865  * @brief Builds PDSCH serving cell config
5866  * @details
5867  *
5868  *    Function : BuildPdschSrvCellCfg
5869  *
5870  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5871  *
5872  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5873  *
5874  * @return ROK     - success
5875  *         RFAILED - failure
5876  *
5877  * ****************************************************************/
5878 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5879 {
5880    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5881    pdschCfg->choice.setup = NULLP;
5882    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5883    if(!pdschCfg->choice.setup)
5884    {
5885       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5886       return RFAILED;
5887    }
5888
5889    /* Code Block Group Transmission */
5890    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5891    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5892    {
5893       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5894       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5895       {
5896          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5897          return RFAILED;
5898       }
5899
5900       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5901       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5902       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5903       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5904       {
5905          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5906          return RFAILED;
5907       }
5908
5909       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5910          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5911       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5912          *(pdschServCellDb->codeBlkGrpFlushInd);
5913    }
5914
5915    /* xOverhead */
5916    pdschCfg->choice.setup->xOverhead = NULLP;
5917    if(pdschServCellDb && pdschServCellDb->xOverhead)
5918    {
5919       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5920       if(pdschCfg->choice.setup->xOverhead == NULLP)
5921       {
5922          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5923          return RFAILED;
5924       }
5925       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5926    }
5927
5928    /* Number of HARQ processes */
5929    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5930    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5931    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5932    {
5933       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5934       return RFAILED;
5935    }
5936
5937    if(pdschServCellDb == NULLP)
5938    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5939    else
5940    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5941
5942    pdschCfg->choice.setup->pucch_Cell = NULLP;
5943
5944    /* Extension */
5945    pdschCfg->choice.setup->ext1 = NULLP;
5946    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5947    {
5948       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5949       if(pdschCfg->choice.setup->ext1 == NULLP)
5950       {
5951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5952          return RFAILED;
5953       }
5954
5955       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5956       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
5957       {
5958          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5959          return RFAILED;
5960       }
5961       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
5962    }
5963
5964    return ROK;
5965 }
5966
5967 /*******************************************************************
5968  *
5969  * @brief Builds CSI Meas config
5970  * @details
5971  *
5972  *    Function : BuildCsiMeasCfg
5973  *
5974  *    Functionality: Builds CSI Meas config in spCellCfgDed
5975  *
5976  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5977  *
5978  * @return ROK     - success
5979  *         RFAILED - failure
5980  *
5981  * ****************************************************************/
5982 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5983 {
5984
5985    return ROK;
5986 }
5987
5988 /*******************************************************************
5989  *
5990  * @brief Builds DL BWP to add/modify list
5991  * @details
5992  *
5993  *    Function : BuildDlBwpToAddModList
5994  *
5995  *    Functionality: Builds DL BWP to add/modify list
5996  *
5997  * @params[in] ServCellCfgInfo *servCellCfg,
5998  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
5999  *
6000  * @return ROK     - success
6001  *         RFAILED - failure
6002  *
6003  * ****************************************************************/
6004 uint8_t BuildDlBwpToAddModList(ServCellCfgInfo *servCellCfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
6005 {
6006    uint8_t elementCnt, idx;
6007
6008    elementCnt = servCellCfg->numDlBwpToAdd;
6009    dlBwpAddModList->list.count = elementCnt;
6010    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6011    dlBwpAddModList->list.array = NULLP;
6012    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6013    if(dlBwpAddModList->list.array == NULLP)
6014    {
6015       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6016       return RFAILED;
6017    }
6018
6019    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6020    {
6021       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6022       if(dlBwpAddModList->list.array[idx] == NULLP)
6023       {
6024          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6025          return RFAILED;
6026       }
6027    }
6028
6029    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6030    {
6031       dlBwpAddModList->list.array[idx]->bwp_Id = servCellCfg->DlBwpToAddList[idx].bwpId;
6032       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6033       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6034    }
6035    return ROK;
6036 }
6037
6038 /*******************************************************************
6039  *
6040  * @brief Builds Spcell config dedicated
6041  * @details
6042  *
6043  *    Function : BuildSpCellCfgDed
6044  *
6045  *    Functionality: Builds sp cell config dedicated in spCellCfg
6046  *
6047  * @params[in] ServingCellConfig_t srvCellCfg
6048  *
6049  * @return ROK     - success
6050  *         RFAILED - failure
6051  *
6052  * ****************************************************************/
6053 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6054 {
6055    ServCellCfgInfo *servCellCfg = NULLP;
6056    InitialDlBwp *initDlBwp = NULLP;
6057    PdschServCellCfg *pdschServCellDb = NULLP;
6058
6059    if(ueCb)
6060    {
6061       servCellCfg = &ueCb->macUeCfg.spCellCfg.servCellCfg;
6062       initDlBwp = &servCellCfg->initDlBwp;
6063       pdschServCellDb = &servCellCfg->pdschServCellCfg;
6064    }
6065
6066    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6067    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6068    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6069    {
6070       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6071       return RFAILED;
6072    }
6073
6074    srvCellCfg->initialDownlinkBWP = NULLP;
6075    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6076    if(!srvCellCfg->initialDownlinkBWP)
6077    {
6078       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6079       return RFAILED;
6080    }
6081
6082    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6083    {
6084       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6085       return RFAILED;
6086    }
6087
6088    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6089
6090    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6091    if(ueCb && ueCb->macUeCfg.spCellCfg.servCellCfg.numDlBwpToAdd)
6092    {
6093       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6094       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6095       {
6096          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6097          return RFAILED;
6098       }
6099
6100       if(BuildDlBwpToAddModList(&ueCb->macUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6101       {
6102          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6103          return RFAILED;
6104       }
6105    }
6106
6107    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6108    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6109    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6110    {
6111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6112       return RFAILED;
6113    }
6114    if(ueCb == NULLP)
6115       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6116    else
6117       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6118
6119    srvCellCfg->bwp_InactivityTimer = NULLP;
6120
6121    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6122    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6123    if(!srvCellCfg->defaultDownlinkBWP_Id)
6124    {
6125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6126       return RFAILED;
6127    }
6128    if(ueCb == NULLP)
6129       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6130    else
6131       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6132
6133    srvCellCfg->uplinkConfig = NULLP;
6134    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6135    if(!srvCellCfg->uplinkConfig)
6136    {
6137       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6138       return RFAILED;
6139    }
6140
6141    if(BuildUlCfg(servCellCfg, srvCellCfg->uplinkConfig) != ROK)
6142    {
6143       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6144       return RFAILED;
6145    }
6146    srvCellCfg->supplementaryUplink = NULLP;
6147    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6148
6149    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6150    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6151    if(!srvCellCfg->pdsch_ServingCellConfig)
6152    {
6153       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6154       return RFAILED;
6155    }
6156
6157    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6158    {
6159       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6160       return RFAILED;
6161    }
6162
6163    srvCellCfg->csi_MeasConfig = NULLP;
6164 #if 0
6165    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6166       if(!srvCellCfg->csi_MeasConfig)
6167       {
6168          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6169          return RFAILED;
6170       }
6171
6172    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6173    {
6174       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6175       return RFAILED;
6176    }
6177 #endif
6178    srvCellCfg->sCellDeactivationTimer = NULLP;
6179    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6180    srvCellCfg->tag_Id = TAG_ID;
6181    srvCellCfg->dummy = NULLP;
6182    srvCellCfg->pathlossReferenceLinking = NULLP;
6183    srvCellCfg->servingCellMO = NULLP;
6184    srvCellCfg->ext1 = NULLP;
6185
6186    return ROK;
6187 }
6188 /*******************************************************************
6189  *
6190  * @brief Builds Spcell config
6191  *
6192  * @details
6193  *
6194  *    Function : BuildSpCellCfg
6195  *
6196  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6197  *
6198  * @params[in] SpCellConfig_t spCellCfg
6199  *
6200  * @return ROK     - success
6201  *         RFAILED - failure
6202  *
6203  * ****************************************************************/
6204 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6205 {
6206    spCellCfg->servCellIndex = NULLP;
6207    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6208    if(!spCellCfg->servCellIndex)
6209    {
6210       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6211       return RFAILED;
6212    }
6213
6214    if(ueCb == NULLP)
6215       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6216    else
6217       *(spCellCfg->servCellIndex) = ueCb->macUeCfg.spCellCfg.servCellIdx;
6218
6219    spCellCfg->reconfigurationWithSync = NULLP;
6220    spCellCfg->rlf_TimersAndConstants = NULLP;
6221    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6222
6223    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6224    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6225    {
6226       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6227       return RFAILED;
6228    }
6229    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6230
6231    spCellCfg->spCellConfigDedicated = NULLP;
6232    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6233    if(!spCellCfg->spCellConfigDedicated)
6234    {
6235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6236       return RFAILED;
6237    }
6238    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6239    {
6240       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6241       return RFAILED;
6242    }
6243
6244    return ROK;
6245 }
6246
6247 /*******************************************************************
6248  *
6249  * @brief Builds Phy cell group config
6250  *
6251  * @details
6252  *
6253  *    Function : BuildPhyCellGrpCfg
6254  *
6255  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6256  *
6257  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
6258  *
6259  * @return ROK     - success
6260  *         RFAILED - failure
6261  *
6262  * ****************************************************************/
6263 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
6264 {
6265    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
6266    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
6267
6268    phyCellGrpCfg->p_NR_FR1 = NULLP;
6269    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6270    if(!phyCellGrpCfg->p_NR_FR1)
6271    {
6272       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
6273       return RFAILED;
6274    }
6275
6276    if(ueCb == NULLP)
6277    {
6278       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
6279       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
6280    }
6281    else
6282    {
6283       *(phyCellGrpCfg->p_NR_FR1) = ueCb->macUeCfg.phyCellGrpCfg.pNrFr1;
6284       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->macUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
6285    }
6286
6287    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
6288    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
6289    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
6290    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
6291    phyCellGrpCfg->cs_RNTI = NULLP;
6292    phyCellGrpCfg->ext1 = NULLP;
6293    phyCellGrpCfg->ext2 = NULLP;
6294
6295    return ROK;
6296 }
6297
6298 /*******************************************************************
6299  *
6300  * @brief Builds Mac cell group config
6301  *
6302  * @details
6303  *
6304  *    Function : BuildMacCellGrpCfg
6305  *
6306  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
6307  *
6308  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
6309  *
6310  * @return ROK     - success
6311  *         RFAILED - failure
6312  *
6313  * ****************************************************************/
6314 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
6315 {
6316    macCellGrpCfg->drx_Config = NULLP;
6317    macCellGrpCfg->schedulingRequestConfig = NULLP;
6318    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6319    if(!macCellGrpCfg->schedulingRequestConfig)
6320    {
6321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6322       return RFAILED;
6323    }
6324
6325    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
6326    {
6327       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
6328       return RFAILED;
6329    }
6330
6331    macCellGrpCfg->bsr_Config = NULLP;
6332    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6333    if(!macCellGrpCfg->bsr_Config)
6334    {
6335       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6336       return RFAILED;
6337    }
6338
6339    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
6340    {
6341       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
6342       return RFAILED;
6343    }
6344
6345    macCellGrpCfg->tag_Config = NULLP;
6346    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
6347    if(!macCellGrpCfg->tag_Config)
6348    {
6349       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6350       return RFAILED;
6351    }
6352
6353    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
6354    {
6355       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
6356       return RFAILED;
6357    }
6358
6359    macCellGrpCfg->phr_Config = NULLP;
6360    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
6361    if(!macCellGrpCfg->phr_Config)
6362    {
6363       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
6364       return RFAILED;
6365    }
6366
6367    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
6368    {
6369       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
6370       return RFAILED;
6371    }
6372
6373    macCellGrpCfg->skipUplinkTxDynamic = false;
6374    macCellGrpCfg->ext1 = NULLP;
6375
6376    return ROK;
6377 }
6378 /*******************************************************************
6379  *
6380  * @brief Frees memeory allocated for SearchSpcToAddModList
6381  *
6382  * @details
6383  *
6384  *    Function : FreeSearchSpcToAddModList
6385  *
6386  *    Functionality: Deallocating memory of SearchSpcToAddModList
6387  *
6388  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6389  *
6390  * @return void
6391  *
6392  4221 * ****************************************************************/
6393 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6394 {
6395    uint8_t idx1=0;
6396    uint8_t idx2=0;
6397    struct  SearchSpace *searchSpc=NULLP;
6398
6399    if(searchSpcList->list.array)
6400    {
6401       if(searchSpcList->list.array[idx2])
6402       {
6403          searchSpc = searchSpcList->list.array[idx2];
6404          if(searchSpc->controlResourceSetId)
6405          {
6406             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6407             {
6408                if(searchSpc->monitoringSymbolsWithinSlot)
6409                {
6410                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6411                   {
6412                      if(searchSpc->nrofCandidates)
6413                      {
6414                         if(searchSpc->searchSpaceType)
6415                         {
6416                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
6417                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
6418                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
6419                                     SearchSpace__searchSpaceType));
6420                         }
6421                         DU_FREE(searchSpc->nrofCandidates,
6422                               sizeof(struct SearchSpace__nrofCandidates));
6423                      }
6424                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
6425                            searchSpc->monitoringSymbolsWithinSlot->size);
6426                   }
6427                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
6428                         sizeof(BIT_STRING_t));
6429                }
6430                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
6431                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
6432             }
6433             DU_FREE(searchSpc->controlResourceSetId,
6434                   sizeof(ControlResourceSetId_t));
6435          }
6436       }
6437       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
6438       {
6439          DU_FREE(searchSpcList->list.array[idx1],
6440                sizeof(struct SearchSpace));
6441       }
6442       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
6443    }
6444 }
6445 /*******************************************************************
6446  *
6447  * @brief Frees memory allocated for PdschTimeDomAllocList
6448  *
6449  * @details
6450  *
6451  *    Function : FreePdschTimeDomAllocList
6452  *
6453  *    Functionality: Deallocating memory of PdschTimeDomAllocList
6454  *
6455  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6456  *
6457  * @return void
6458  *
6459  * ****************************************************************/
6460 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6461 {
6462    uint8_t idx1=0;
6463
6464    if(timeDomAllocList->choice.setup)
6465    {
6466       if(timeDomAllocList->choice.setup->list.array)
6467       {
6468          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
6469          {
6470             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
6471             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
6472                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
6473          }
6474          DU_FREE(timeDomAllocList->choice.setup->list.array, \
6475                timeDomAllocList->choice.setup->list.size);
6476       }
6477       DU_FREE(timeDomAllocList->choice.setup,\
6478             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
6479    }
6480 }
6481 /*******************************************************************
6482  *
6483  * @brief Frees memory allocated for PuschTimeDomAllocList
6484  *
6485  *@details
6486  *
6487  *    Function : FreePuschTimeDomAllocList
6488  *
6489  *    Functionality: Deallocating memory of PuschTimeDomAllocList
6490  *
6491  * @params[in] PUSCH_Config_t *puschCfg
6492  *
6493  * @return void
6494  *
6495  * ****************************************************************/
6496 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
6497 {
6498    uint8_t rsrcListIdx=0;
6499    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6500
6501    if(puschCfg->pusch_TimeDomainAllocationList)
6502    {
6503       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6504       if(timeDomAllocList_t->choice.setup)
6505       {
6506          if(timeDomAllocList_t->choice.setup->list.array)
6507          {
6508             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
6509             {
6510                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
6511                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
6512                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
6513             }
6514             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
6515                   timeDomAllocList_t->choice.setup->list.size);
6516          }
6517          DU_FREE(timeDomAllocList_t->choice.setup, \
6518                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
6519       }
6520       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
6521       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
6522             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
6523    }
6524
6525 }
6526
6527 /*******************************************************************
6528  *
6529  * @brief Frees memory allocated for Dedicated PUCCH config
6530  *
6531  * @details
6532  *
6533  *    Function : FreeBWPUlDedPucchCfg
6534  *
6535  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
6536  *
6537  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
6538  *
6539  * @return void
6540  *
6541  * ****************************************************************/
6542 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
6543 {
6544    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
6545    PUCCH_Config_t *pucchCfg = NULLP;
6546    PUCCH_ResourceSet_t *rsrcSet = NULLP;
6547    PUCCH_Resource_t *rsrc = NULLP;
6548
6549    if(ulBwpPucchCfg)
6550    {
6551       if(ulBwpPucchCfg->choice.setup)
6552       {
6553          pucchCfg = ulBwpPucchCfg->choice.setup;
6554
6555          //Free resource set list
6556          if(pucchCfg->resourceSetToAddModList)
6557          {
6558             if(pucchCfg->resourceSetToAddModList->list.array)
6559             {
6560                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
6561                {
6562                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
6563                   if(rsrcSet->resourceList.list.array)
6564                   {
6565                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
6566                      {
6567                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
6568                      }
6569                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
6570                   }
6571                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
6572                }
6573                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
6574             }
6575             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
6576          }
6577
6578          //Free resource list
6579          if(pucchCfg->resourceToAddModList)
6580          {
6581             if(pucchCfg->resourceToAddModList->list.array)
6582             {
6583                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
6584                {
6585                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
6586                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
6587                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
6588                }
6589                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
6590             }
6591             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
6592          }
6593
6594          //PUCCH Format 1
6595          if(pucchCfg->format1)
6596          {
6597             if(pucchCfg->format1->choice.setup)
6598             {
6599                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
6600                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
6601             }
6602             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
6603          }
6604
6605          //DL DATA TO UL ACK
6606          if(pucchCfg->dl_DataToUL_ACK)
6607          {
6608             if(pucchCfg->dl_DataToUL_ACK->list.array)
6609             {
6610                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
6611                {
6612                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
6613                }
6614                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
6615             }
6616             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
6617          }
6618
6619          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
6620       }
6621       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
6622    }
6623 }
6624
6625 /*******************************************************************
6626  *
6627  * @brief Frees memory allocated for InitialUlBWP
6628  *
6629  * @details
6630  *
6631  *    Function : FreeInitialUlBWP
6632  *
6633  *    Functionality: Deallocating memory of InitialUlBWP
6634  *
6635  * @params[in] BWP_UplinkDedicated_t *ulBwp
6636  *
6637  * @return void
6638  *
6639  * ****************************************************************/
6640 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
6641 {
6642    uint8_t  rSetIdx, rsrcIdx;
6643    SRS_Config_t   *srsCfg = NULLP;
6644    PUSCH_Config_t *puschCfg = NULLP;
6645    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6646    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6647    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6648    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6649
6650    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
6651
6652    if(ulBwp->pusch_Config)
6653    {
6654       if(ulBwp->pusch_Config->choice.setup)
6655       {
6656          puschCfg=ulBwp->pusch_Config->choice.setup;
6657          if(puschCfg->dataScramblingIdentityPUSCH)
6658          {
6659             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6660             {
6661                FreePuschTimeDomAllocList(puschCfg);
6662                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6663                if(dmrsUlCfg->choice.setup)
6664                {
6665                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6666                   {
6667                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6668                      {
6669                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
6670                               sizeof(long));
6671                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
6672                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
6673                      }
6674                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
6675                            sizeof(long));
6676                   }
6677                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
6678                }
6679                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
6680                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
6681             }
6682             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
6683          }
6684          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
6685       }
6686       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
6687
6688       /* Free SRS-Config */
6689       if(ulBwp->srs_Config)
6690       {
6691          if(ulBwp->srs_Config->choice.setup)
6692          {
6693             srsCfg = ulBwp->srs_Config->choice.setup;
6694
6695             /* Free Resource Set to add/mod list */
6696             if(srsCfg->srs_ResourceSetToAddModList)
6697             {
6698                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6699                if(rsrcSetList->list.array)
6700                {
6701                   rSetIdx = 0;
6702
6703                   /* Free SRS resource Id list in this SRS resource set */
6704                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6705                   {
6706                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6707
6708                      if(rsrcIdList->list.array)
6709                      {
6710                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
6711                         {
6712                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
6713                         }
6714                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
6715                      }
6716                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
6717                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
6718                   }
6719
6720                   /* Free resource type info for this SRS resource set */
6721                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
6722                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
6723
6724                   /* Free memory for each resource set */
6725                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6726                   {
6727                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
6728                   }
6729                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
6730                }
6731                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
6732                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
6733             }
6734
6735             /* Free resource to add/modd list */
6736             if(srsCfg->srs_ResourceToAddModList)
6737             {
6738                resourceList = srsCfg->srs_ResourceToAddModList;
6739                if(resourceList->list.array)
6740                {
6741                   rsrcIdx = 0;
6742                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
6743                         sizeof(struct SRS_Resource__transmissionComb__n2));
6744                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
6745                         sizeof(struct SRS_Resource__resourceType__aperiodic));
6746
6747                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6748                   {
6749                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
6750                   }
6751                   DU_FREE(resourceList->list.array, resourceList->list.size);
6752                }
6753                DU_FREE(srsCfg->srs_ResourceToAddModList, \
6754                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
6755             }
6756
6757             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
6758          }
6759          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
6760       }
6761    }
6762 }
6763 /*******************************************************************
6764  *
6765  * @brief Frees memory allocated for initialUplinkBWP
6766  *
6767  * @details
6768  *
6769  *    Function : FreeinitialUplinkBWP
6770  *
6771  *    Functionality: Deallocating memory of initialUplinkBWP
6772  *
6773  * @params[in] UplinkConfig_t *ulCfg
6774  *
6775  * @return void
6776  *
6777  *
6778  * ****************************************************************/
6779 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
6780 {
6781    BWP_UplinkDedicated_t *ulBwp=NULLP;
6782    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6783
6784    if(ulCfg->initialUplinkBWP)
6785    {
6786       ulBwp=ulCfg->initialUplinkBWP;
6787       if(ulCfg->firstActiveUplinkBWP_Id)
6788       {
6789          if(ulCfg->pusch_ServingCellConfig)
6790          {
6791             puschCfg=ulCfg->pusch_ServingCellConfig;
6792             if(puschCfg->choice.setup)
6793             {
6794                if(puschCfg->choice.setup->ext1)
6795                {
6796                   DU_FREE(puschCfg->choice.setup->ext1->\
6797                         processingType2Enabled,sizeof(BOOLEAN_t));
6798                   DU_FREE(puschCfg->choice.setup->ext1->\
6799                         maxMIMO_Layers,sizeof(long));
6800                   DU_FREE(puschCfg->choice.setup->ext1, \
6801                         sizeof(struct PUSCH_ServingCellConfig__ext1));
6802                }
6803                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
6804             }
6805             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
6806          }
6807          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
6808       }
6809       FreeInitialUlBWP(ulBwp);
6810       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
6811    }
6812 }
6813 /*******************************************************************
6814  *
6815  * @brief Frees emmory allocated for BWPDlDedPdschCfg
6816  *
6817  * @details
6818  *
6819  *    Function : FreeBWPDlDedPdschCfg
6820  *
6821  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
6822  *
6823  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6824  *
6825  * @return void
6826  *
6827  *
6828  * ****************************************************************/
6829 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
6830 {
6831    struct PDSCH_Config *pdschCfg=NULLP;
6832    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6833    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6834    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6835
6836    if(dlBwp->pdsch_Config->choice.setup)
6837    {
6838       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6839       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6840       {
6841          if(pdschCfg->pdsch_TimeDomainAllocationList)
6842          {
6843             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6844             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6845             {
6846                prbBndlType=&pdschCfg->prb_BundlingType;
6847                DU_FREE(prbBndlType->choice.staticBundling,\
6848                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
6849                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
6850             }
6851             FreePdschTimeDomAllocList(timeDomAllocList);
6852             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
6853                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6854          }
6855          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6856          if(dmrsDlCfg->choice.setup)
6857          {
6858             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6859                   sizeof(long));
6860             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6861          }
6862          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6863                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6864       }
6865       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6866    }
6867 }
6868 /*******************************************************************
6869  *
6870  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6871  *
6872  * @details
6873  *
6874  *    Function : FreeBWPDlDedPdcchCfg
6875  *
6876  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6877  *
6878  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6879  *
6880  * @return void
6881  *
6882  *
6883  * ****************************************************************/
6884 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6885 {
6886    uint8_t idx1=0;
6887    uint8_t idx2=0;
6888    struct PDCCH_Config *pdcchCfg=NULLP;
6889    struct ControlResourceSet *controlRSet=NULLP;
6890    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6891
6892    if(dlBwp->pdcch_Config->choice.setup)
6893    {
6894       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6895       if(pdcchCfg->controlResourceSetToAddModList)
6896       {
6897          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6898          if(controlRSetList->list.array)
6899          {
6900             controlRSet = controlRSetList->list.array[idx2];
6901             if(controlRSet)
6902             {
6903                if(controlRSet->frequencyDomainResources.buf)
6904                {
6905                   if(controlRSet->pdcch_DMRS_ScramblingID)
6906                   {
6907                      if(pdcchCfg->searchSpacesToAddModList)
6908                      {
6909                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6910                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
6911                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6912                      }
6913                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6914                   }
6915                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
6916                         controlRSet->frequencyDomainResources.size);
6917                }
6918             }
6919             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6920             {
6921                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6922             }
6923             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6924          }
6925          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6926                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6927       }
6928       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6929    }
6930 }
6931
6932 /*******************************************************************
6933  *
6934  * @brief Frees emmory allocated for DUToCURRCContainer
6935  *
6936  * @details
6937  *
6938  *    Function : FreeMemDuToCuRrcCont
6939  *
6940  *    Functionality: Deallocating memory of DuToCuRrcContainer
6941  *
6942  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
6943  *
6944  * @return ROK     - success
6945  *         RFAILED - failure
6946  *
6947  * ****************************************************************/
6948 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
6949 {
6950    uint8_t idx=0;
6951    SpCellConfig_t *spCellCfg=NULLP;
6952    ServingCellConfig_t *srvCellCfg=NULLP;
6953    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6954    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6955    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6956    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6957    struct RLC_Config *rlcConfig=NULLP;
6958    struct LogicalChannelConfig *macLcConfig=NULLP;
6959    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6960    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6961    struct TAG_Config *tagConfig=NULLP;
6962    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6963    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6964    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6965
6966    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6967    if(rlcBearerList)
6968    {
6969       if(rlcBearerList->list.array)
6970       {
6971          for(idx=0; idx<rlcBearerList->list.count; idx++)
6972          {
6973             if(rlcBearerList->list.array[idx])
6974             {
6975                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6976                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6977                if(rlcConfig)
6978                {
6979                   if(rlcConfig->choice.am)
6980                   {
6981                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6982                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6983                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6984                   }
6985                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
6986                }
6987                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6988                if(macLcConfig)
6989                {
6990                   if(macLcConfig->ul_SpecificParameters)
6991                   {
6992                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6993                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6994                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6995                   }
6996                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6997                }
6998                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6999             }
7000          }
7001          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
7002       }
7003       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
7004    }
7005
7006    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
7007    if(macCellGrpCfg)
7008    {
7009       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
7010       if(schedulingRequestConfig)
7011       {
7012          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
7013          if(schReqList)
7014          {
7015             if(schReqList->list.array)
7016             {
7017                for(idx=0;idx<schReqList->list.count; idx++)
7018                {
7019                   if(schReqList->list.array[idx])
7020                   {
7021                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
7022                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
7023                   }
7024                }
7025                DU_FREE(schReqList->list.array, schReqList->list.size);
7026             }
7027             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
7028                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
7029             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7030       }
7031       if(macCellGrpCfg->bsr_Config)
7032       {
7033          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7034       }
7035       tagConfig = macCellGrpCfg->tag_Config;
7036       if(tagConfig)
7037       {
7038          tagList = tagConfig->tag_ToAddModList;
7039          if(tagList)
7040          {
7041             if(tagList->list.array)
7042             {
7043                for(idx=0; idx<tagList->list.count; idx++)
7044                {
7045                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
7046                }
7047                DU_FREE(tagList->list.array, tagList->list.size);
7048             }
7049             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
7050          }
7051          DU_FREE(tagConfig, sizeof(struct TAG_Config));
7052       }
7053
7054       phrConfig = macCellGrpCfg->phr_Config;
7055       if(phrConfig)
7056       {
7057          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
7058          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
7059       }
7060
7061       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
7062    }
7063
7064    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7065    if(phyCellGrpCfg)
7066    {
7067       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
7068       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
7069    }
7070
7071    spCellCfg = cellGrpCfg->spCellConfig;
7072    if(spCellCfg)
7073    {
7074       if(spCellCfg->servCellIndex)
7075       {
7076          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7077          {
7078             if(spCellCfg->spCellConfigDedicated)
7079             {
7080                srvCellCfg = spCellCfg->spCellConfigDedicated;
7081                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
7082                {
7083                   if(srvCellCfg->initialDownlinkBWP)
7084                   {
7085                      dlBwp = srvCellCfg->initialDownlinkBWP;
7086                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7087                      {
7088                         if(srvCellCfg->defaultDownlinkBWP_Id)
7089                         {
7090                            if(srvCellCfg->uplinkConfig)
7091                            {
7092                               if(srvCellCfg->pdsch_ServingCellConfig)
7093                               {
7094                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
7095                                  if(pdschCfg->choice.setup)
7096                                  {
7097                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
7098                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
7099                                  }
7100                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
7101                                           ServingCellConfig__pdsch_ServingCellConfig));
7102                               }
7103                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
7104                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
7105                            }
7106                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
7107                         }
7108                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
7109                      }
7110                      if(dlBwp->pdcch_Config)
7111                      {
7112                         if(dlBwp->pdsch_Config)
7113                         {
7114                            FreeBWPDlDedPdschCfg(dlBwp);
7115                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
7116                         }
7117                         FreeBWPDlDedPdcchCfg(dlBwp);
7118                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
7119                      }
7120                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
7121                   }
7122                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
7123                }
7124                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
7125             }
7126             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
7127          }
7128          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
7129       }
7130       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
7131    }
7132    return ROK;
7133 }
7134
7135 /*******************************************************************
7136  *
7137  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
7138  *
7139  * @details
7140  *
7141  *    Function : BuildCellGroupConfigRrc
7142  *
7143  *    Functionality: Builds and copied Cell group config buffer into
7144  *       DuToCuRrcContainer
7145  *
7146  * @params[in] idx, index in F1AP msg
7147  *             DuToCuRRCContainer, DuToCuRRCContainer
7148  *
7149  * @return ROK     - success
7150  *         RFAILED - failure
7151  *
7152  * ****************************************************************/
7153 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
7154 {
7155    uint8_t  ret = ROK;
7156    CellGroupConfigRrc_t  cellGrpCfg;
7157    asn_enc_rval_t        encRetVal;
7158    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
7159    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
7160
7161    while(true)
7162    {
7163       cellGrpCfg.cellGroupId = CELL_GRP_ID;
7164
7165       cellGrpCfg.rlc_BearerToAddModList = NULLP;
7166       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
7167       if(!cellGrpCfg.rlc_BearerToAddModList)
7168       {
7169          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7170          ret = RFAILED;
7171          break;
7172       }
7173       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
7174       {
7175          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
7176          ret = RFAILED;
7177          break;
7178       }
7179
7180       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
7181       cellGrpCfg.mac_CellGroupConfig = NULLP;
7182       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
7183       if(!cellGrpCfg.mac_CellGroupConfig)
7184       {
7185          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7186          ret = RFAILED;
7187          break;
7188       }
7189       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
7190       {
7191          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
7192          ret = RFAILED;
7193          break;
7194       }
7195
7196       cellGrpCfg.physicalCellGroupConfig = NULLP;
7197       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
7198       if(!cellGrpCfg.physicalCellGroupConfig)
7199       {
7200          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7201          ret = RFAILED;
7202          break;
7203       }
7204       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
7205       {
7206          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
7207          ret = RFAILED;
7208          break;
7209       }
7210
7211       cellGrpCfg.spCellConfig = NULLP;
7212       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
7213       if(!cellGrpCfg.spCellConfig)
7214       {
7215          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
7216          ret = RFAILED;
7217          break;
7218       }
7219       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
7220       {
7221          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
7222          ret = RFAILED;
7223          break;
7224       }
7225
7226       cellGrpCfg.sCellToAddModList = NULLP;
7227       cellGrpCfg.sCellToReleaseList = NULLP;
7228       cellGrpCfg.ext1 = NULLP;
7229
7230       /* encode cellGrpCfg into duToCuRrcContainer */
7231       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
7232       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7233       encBufSize = 0;
7234       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
7235       /* Encode results */
7236       if(encRetVal.encoded == ENCODE_FAIL)
7237       {
7238          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
7239                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7240          ret = RFAILED;
7241          break;
7242       }
7243       else
7244       {
7245          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
7246          for(int i=0; i< encBufSize; i++)
7247          {
7248             printf("%x",encBuf[i]);
7249          }
7250       }
7251
7252       duToCuRrcContainer->size = encBufSize;
7253       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
7254       if(!duToCuRrcContainer->buf)
7255       {
7256          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
7257          ret = RFAILED;
7258          break;
7259       }
7260       if(ret == ROK)
7261       {
7262          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
7263       }
7264       break;
7265    }
7266    FreeMemDuToCuRrcCont(&cellGrpCfg);
7267    return ret;
7268 }
7269
7270 /*******************************************************************
7271  *
7272  * @brief Free memory allocated in InitialULRRCMessage
7273  *
7274  * @details
7275  *
7276  *    Function : freeInitUlRrcMsgTransfer
7277  *
7278  *    Functionality: Free memory allocated in InitialULRRCMessage
7279  *
7280  * @params[in]F1AP_PDU_t  *f1apMsg)
7281  *
7282  * @return ROK     - success
7283  *         RFAILED - failure
7284  *
7285  * ****************************************************************/
7286
7287 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
7288 {
7289    uint8_t ieIdx, arrIdx;
7290    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
7291
7292    if(f1apMsg)
7293    {
7294       if(f1apMsg->choice.initiatingMessage)
7295       {
7296          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
7297             choice.InitialULRRCMessageTransfer;
7298          if(initULRRCMsg->protocolIEs.list.array)
7299          {
7300             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
7301             {
7302                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
7303                {
7304                   case ProtocolIE_ID_id_NRCGI:
7305                   {
7306                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
7307                      {
7308                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
7309                         {
7310                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
7311                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
7312                         }
7313                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
7314                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
7315                      }
7316                      break;
7317                   }
7318                   case ProtocolIE_ID_id_RRCContainer:
7319                   {
7320                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
7321                      {
7322                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
7323                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
7324                      }
7325                      break;
7326                   }
7327                   case ProtocolIE_ID_id_DUtoCURRCContainer:
7328                   {
7329                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
7330                      {
7331                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
7332                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
7333                      }
7334                      break;
7335                   }
7336                   default:
7337                      break;
7338                }
7339              }
7340              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
7341              {
7342                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
7343                 {
7344                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
7345                       sizeof(InitialULRRCMessageTransferIEs_t));
7346                 }
7347              }
7348              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
7349           }
7350          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
7351       }
7352       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7353    }
7354    else
7355    {
7356       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
7357       return RFAILED;
7358    }
7359    return ROK;
7360 }
7361
7362 /*******************************************************************
7363  *
7364  * @brief Builds and sends the InitialULRRCMessage
7365  *
7366  * @details
7367  *
7368  *    Function : BuildAndSendInitialRrcMsgTransfer
7369  *
7370  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
7371  *                   it to the CU through SCTP.
7372  *
7373  * @params[in]
7374  *
7375  * @return ROK     - success
7376  *         RFAILED - failure
7377  *
7378  * ****************************************************************/
7379 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
7380       uint16_t rrcContSize, uint8_t *rrcContainer)
7381 {
7382    uint8_t   ret;
7383    uint8_t   elementCnt;
7384    uint8_t   ieIdx, cellIdx, ueIdx;
7385    DuUeCb    *duUeCb = NULLP;
7386    asn_enc_rval_t  encRetVal;
7387    F1AP_PDU_t  *f1apMsg = NULLP;
7388    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
7389    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
7390
7391    while(true)
7392    {
7393       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
7394       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7395       if(f1apMsg == NULLP)
7396       {
7397          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
7398          break;
7399       }
7400       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
7401       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
7402       if(f1apMsg->choice.initiatingMessage == NULLP)
7403       {
7404          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
7405          break;
7406       }
7407       f1apMsg->choice.initiatingMessage->procedureCode =\
7408                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
7409       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
7410       f1apMsg->choice.initiatingMessage->value.present = \
7411                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
7412       initULRRCMsg =\
7413                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
7414       elementCnt = 5;
7415       initULRRCMsg->protocolIEs.list.count = elementCnt;
7416       initULRRCMsg->protocolIEs.list.size = \
7417                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
7418       /* Initialize the F1Setup members */
7419       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
7420       if(initULRRCMsg->protocolIEs.list.array == NULLP)
7421       {
7422          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
7423                RRCSetupRequestMessageTransferIEs failed");
7424          break;
7425       }
7426       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
7427       {
7428          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
7429                sizeof(InitialULRRCMessageTransferIEs_t));
7430          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
7431          {
7432             break;
7433          }
7434       }
7435       ieIdx = 0;
7436       /*GNB DU UE F1AP ID*/
7437       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7438                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
7439       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
7440       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
7441                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
7442       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
7443
7444
7445       /*NRCGI*/
7446       ieIdx++;
7447       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7448                                                         ProtocolIE_ID_id_NRCGI;
7449       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
7450       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
7451                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
7452
7453       ret =\
7454            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
7455       if(ret!=ROK)
7456       {
7457          break;
7458       }
7459
7460       /*CRNTI*/
7461       ieIdx++;
7462       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7463                                                         ProtocolIE_ID_id_C_RNTI;
7464       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7465       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7466                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
7467       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
7468
7469       /*RRCContainer*/
7470       ieIdx++;
7471       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
7472                                                         ProtocolIE_ID_id_RRCContainer;
7473       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7474       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7475                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
7476
7477       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
7478       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
7479             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
7480       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
7481       {
7482          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
7483          break;
7484
7485       }
7486       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
7487             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
7488
7489
7490       /*DUtoCURRCContainer*/
7491       ieIdx++;
7492       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
7493       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7494       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
7495                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
7496
7497       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
7498       {
7499          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
7500          {
7501             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
7502                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
7503             {
7504                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
7505             }
7506          }
7507       }
7508
7509       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
7510       if(ret != ROK)
7511       {
7512          break;
7513       }
7514
7515       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7516
7517       /* Encode the Intial UL RRC Message transfer as APER */
7518       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7519       encBufSize = 0;
7520       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
7521       /* Encode results */
7522       if(encRetVal.encoded == ENCODE_FAIL)
7523       {
7524          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
7525                structure (at %s)\n",encRetVal.failed_type ? \
7526                encRetVal.failed_type->name : "unknown");
7527          ret = RFAILED;
7528          break;
7529       }
7530       else
7531       {
7532
7533          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
7534                Message transfer\n");
7535          for(int i=0; i< encBufSize; i++)
7536          {
7537             printf("%x",encBuf[i]);
7538          }
7539       }
7540       /* Sending  msg  */
7541       if(sendF1APMsg() != ROK)
7542       {
7543          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
7544          ret = RFAILED;
7545          break;
7546       }
7547       break;
7548    }
7549    freeInitUlRrcMsgTransfer(f1apMsg);
7550    return ret;
7551 }/* End of BuildAndSendInitialRrcMsgTransfer*/
7552
7553 /*****  UE SETUP REQUEST *****/
7554
7555 /*******************************************************************
7556  *
7557  * @brief Free Qos And Snssai Drb Info
7558  *
7559  * @details
7560  *
7561  *    Function : freeDrbQosAndSnssaiInfo
7562  *
7563  *    Functionality: Free Qos And Snssai Drb Info
7564  *
7565  * @params[in] LcCfg *lcCfg,
7566  * @return void
7567  *
7568  * ****************************************************************/
7569 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
7570 {
7571    if(lcCfg->snssai)
7572    {
7573       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7574    }
7575    if(lcCfg->drbQos)
7576    {
7577       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
7578    }
7579 }
7580
7581 /******************************************************************
7582 *
7583 * @brief Function to delete the RLC Lc cfg from UE APP DB
7584 *
7585 * @details
7586 *
7587 *  Function : freeRlcLcCfg
7588 *
7589 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
7590 *
7591 *
7592  *****************************************************************/
7593
7594 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
7595 {
7596    switch(lcCfg->rlcMode)
7597    {
7598       case RLC_AM :
7599          {
7600             if(lcCfg->u.amCfg)
7601             {
7602                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
7603             }
7604             break;
7605          }
7606       case RLC_UM_BI_DIRECTIONAL :
7607          {
7608             if(lcCfg->u.umBiDirCfg)
7609             {
7610                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7611             }
7612             break;
7613          }
7614       case RLC_UM_UNI_DIRECTIONAL_UL :
7615          {
7616             if(lcCfg->u.umUniDirUlCfg)
7617             {
7618                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7619             }
7620             break;
7621
7622          }
7623       case RLC_UM_UNI_DIRECTIONAL_DL :
7624          {
7625             if(lcCfg->u.umUniDirDlCfg)
7626             {
7627                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7628             }
7629             break;
7630          }
7631       default:
7632          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
7633          break;
7634    }
7635    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7636 }
7637
7638 /*******************************************************************
7639  *
7640  * @brief Function to free MacLcCfg
7641  *
7642  * @details
7643  *
7644  *    Function : freeMacLcCfg
7645  *
7646  *    Functionality: Function to free MacLcCfg
7647  *
7648  * @params[in] LcCfg *lcCfg,
7649  * @return void
7650  *
7651  * ****************************************************************/
7652
7653 void  freeMacLcCfg(LcCfg *lcCfg)
7654 {
7655     /* Deleting DRBQOS */
7656    if(lcCfg->drbQos)
7657    {
7658       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
7659    }
7660    /* Deleting SNSSAI */
7661    if(lcCfg->snssai)
7662    {
7663       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
7664    }
7665 }
7666 /*******************************************************************
7667  *
7668  * @brief Free UE NR Capability received in UE Context setup request
7669  *
7670  * @details
7671  *
7672  *    Function : freeAperDecodeUeNrCapability
7673  *
7674  *    Functionality:
7675  *       Free UE NR Capability received in UE Context setup request
7676  *
7677  * @params[in]
7678  * @return ROK     - success
7679  *         RFAILED - failure
7680  *
7681  * ****************************************************************/
7682 void freeAperDecodeUeNrCapability(void *ueNrCapability)
7683 {
7684    uint8_t arrIdx =0;
7685    FeatureSets_t *featureSets =NULLP;
7686    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
7687
7688    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
7689    {
7690       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
7691       {
7692          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
7693             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
7694       }
7695       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
7696    }
7697
7698    if(ueNrCap->featureSets)
7699    {
7700       featureSets = ueNrCap->featureSets;
7701       if(featureSets->featureSetsDownlinkPerCC)
7702       {
7703          if(featureSets->featureSetsDownlinkPerCC->list.array)
7704          {
7705             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
7706             {
7707                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
7708                {
7709                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
7710                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
7711                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
7712                }
7713             }
7714             free(featureSets->featureSetsDownlinkPerCC->list.array);
7715          }
7716          free(featureSets->featureSetsDownlinkPerCC);
7717       }
7718       if(featureSets->featureSetsUplinkPerCC)
7719       {
7720          if(featureSets->featureSetsUplinkPerCC->list.array)
7721          {
7722             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
7723             {
7724                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
7725                {
7726                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
7727                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
7728                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
7729                }
7730             }
7731             free(featureSets->featureSetsUplinkPerCC->list.array);
7732          }
7733          free(featureSets->featureSetsUplinkPerCC);
7734       }
7735       free(ueNrCap->featureSets);
7736    }
7737 }
7738
7739 /*******************************************************************
7740 *
7741 * @brief Function to free PdcchSearchSpcToAddModList
7742          where memory allocated by aper_decoder
7743 *
7744 * @details
7745 *
7746 *    Function : freeAperDecodePdcchSearchSpcToAddModList
7747 *
7748 *    Functionality: Function to free PdcchSearchSpcToAddModList
7749 *
7750 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7751 * @return void
7752 *
7753 * ****************************************************************/
7754
7755 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7756 {
7757    uint8_t searchSpcArrIdx=0;
7758    uint8_t searchSpcArrIdx1=0;
7759    struct  SearchSpace *searchSpc=NULLP;
7760
7761
7762    if(searchSpcList->list.array)
7763    {
7764       if(searchSpcList->list.array[searchSpcArrIdx1])
7765       {
7766          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
7767          if(searchSpc->controlResourceSetId)
7768          {
7769             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7770             {
7771                if(searchSpc->monitoringSymbolsWithinSlot)
7772                {
7773                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7774                   {
7775                      if(searchSpc->nrofCandidates)
7776                      {
7777                         if(searchSpc->searchSpaceType)
7778                         {
7779                            free(searchSpc->searchSpaceType->choice.ue_Specific);
7780                            free(searchSpc->searchSpaceType);
7781                         }
7782                         free(searchSpc->nrofCandidates);
7783                      }
7784                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
7785                   }
7786                   free(searchSpc->monitoringSymbolsWithinSlot);
7787                }
7788                free(searchSpc->monitoringSlotPeriodicityAndOffset);
7789             }
7790             free(searchSpc->controlResourceSetId);
7791          }
7792       }
7793       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
7794       {
7795          free(searchSpcList->list.array[searchSpcArrIdx]);
7796       }
7797       free(searchSpcList->list.array);
7798    }
7799 }
7800 /*******************************************************************
7801 *
7802 * @brief Function for free part for the memory allocated by aper_decoder
7803 *
7804 * @details
7805 *
7806 *    Function : freeAperDecodeBWPDlDedPdcchConfig
7807 *
7808 *    Functionality: Function to free BWPDlDedPdcchConfig
7809 *
7810 * @params[in]
7811 * @return void
7812 *
7813 * ****************************************************************/
7814
7815
7816 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
7817 {
7818    uint8_t arrIdx1=0;
7819    uint8_t arrIdx2=0;
7820    struct PDCCH_Config *pdcchCfg=NULLP;
7821    struct ControlResourceSet *controlRSet=NULLP;
7822    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7823
7824    if(dlBwp->pdcch_Config->choice.setup)
7825    {
7826       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7827       if(pdcchCfg->controlResourceSetToAddModList)
7828       {
7829          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7830          if(controlRSetList->list.array)
7831          {
7832             controlRSet = controlRSetList->list.array[arrIdx2];
7833             if(controlRSet)
7834             {
7835                if(controlRSet->frequencyDomainResources.buf)
7836                {
7837                   if(controlRSet->pdcch_DMRS_ScramblingID)
7838                   {
7839                      if(pdcchCfg->searchSpacesToAddModList)
7840                      {
7841                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7842                         free(pdcchCfg->searchSpacesToAddModList);
7843                      }
7844                      free(controlRSet->pdcch_DMRS_ScramblingID);
7845                   }
7846                   free(controlRSet->frequencyDomainResources.buf);
7847                }
7848             }
7849             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
7850             {
7851                free(controlRSetList->list.array[arrIdx1]);
7852             }
7853             free(controlRSetList->list.array);
7854          }
7855          free(pdcchCfg->controlResourceSetToAddModList);
7856       }
7857       free(dlBwp->pdcch_Config->choice.setup);
7858    }
7859 }
7860 /*******************************************************************
7861 *
7862 * @brief Function to free PdschTimeDomAllocationList
7863 *     where the memory allocated by aper_decoder
7864 *
7865 * @details
7866 *
7867 *    Function : freeAperDecodePdschTimeDomAllocationList
7868 *
7869 *    Functionality: Function to free PdschTimeDomAllocationList
7870 *
7871 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7872 * @return void
7873 *
7874 * ****************************************************************/
7875
7876
7877 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7878 {
7879    uint8_t arrIdx=0;
7880
7881    if(timeDomAllocList->choice.setup)
7882    {
7883       if(timeDomAllocList->choice.setup->list.array)
7884       {
7885          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
7886          {
7887             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
7888          }
7889          free(timeDomAllocList->choice.setup->list.array);
7890       }
7891       free(timeDomAllocList->choice.setup);
7892    }
7893 }
7894
7895 /*******************************************************************
7896 *
7897 * @brief Function to free BWPDlDedPdschConfig
7898 *        where the memory allocated by aper_decoder
7899 *
7900 * @details
7901 *
7902 *    Function : freeAperDecodeBWPDlDedPdschConfig
7903 *
7904 *    Functionality: Function to free BWPDlDedPdschConfig
7905 *
7906 * @params[in] BWP_DownlinkDedicated_t *dlBwp
7907 * @return void
7908 *
7909 * ****************************************************************/
7910
7911
7912 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
7913 {
7914    struct PDSCH_Config *pdschCfg=NULLP;
7915    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7916    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7917    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7918
7919    if(dlBwp->pdsch_Config->choice.setup)
7920    {
7921       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7922       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7923       {
7924          if(pdschCfg->pdsch_TimeDomainAllocationList)
7925          {
7926             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7927             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7928             {
7929                prbBndlType=&pdschCfg->prb_BundlingType;
7930                free(prbBndlType->choice.staticBundling);
7931                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
7932             }
7933             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
7934             free(pdschCfg->pdsch_TimeDomainAllocationList);
7935          }
7936          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7937          if(dmrsDlCfg->choice.setup)
7938          {
7939             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
7940             free(dmrsDlCfg->choice.setup);
7941          }
7942          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
7943       }
7944       free(dlBwp->pdsch_Config->choice.setup);
7945    }
7946 }
7947 /*******************************************************************
7948 *
7949 * @brief Function to free PuschTimeDomAllocListCfg
7950                  where the memory allocated by aper_decoder
7951 *
7952 * @details
7953 *
7954 *    Function : freeAperDecodePuschTimeDomAllocListCfg
7955 *
7956 *    Functionality: Function to free PuschTimeDomAllocListCfg
7957 *
7958 * @params[in] PUSCH_Config_t *puschCfg
7959 * @return void
7960 *
7961 * ****************************************************************/
7962
7963
7964 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
7965 {
7966    uint8_t arrIdx=0;
7967    uint8_t arrIdx1=0;
7968    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7969
7970    if(puschCfg->pusch_TimeDomainAllocationList)
7971    {
7972       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7973       if(timeDomAllocList_t->choice.setup)
7974       {
7975          if(timeDomAllocList_t->choice.setup->list.array)
7976          {
7977             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
7978             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
7979             {
7980                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
7981             }
7982             free(timeDomAllocList_t->choice.setup->list.array);
7983          }
7984          free(timeDomAllocList_t->choice.setup);
7985       }
7986       free(puschCfg->transformPrecoder);
7987       free(puschCfg->pusch_TimeDomainAllocationList);
7988    }
7989 }
7990 /*******************************************************************
7991 *
7992 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
7993 *
7994 * @details
7995 *
7996 *    Function : freeAperDecodeInitialUlBWPConfig
7997 *
7998 *    Functionality: Function to free InitialUlBWPConfig
7999 *
8000 * @params[in]  BWP_UplinkDedicated_t *ulBwp
8001 * @return void
8002 *
8003 * ****************************************************************/
8004
8005
8006 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
8007 {
8008    uint8_t  rSetIdx =0;
8009    uint8_t  rsrcIdx =0;
8010    SRS_Config_t   *srsCfg = NULLP;
8011    PUSCH_Config_t *puschCfg = NULLP;
8012    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
8013    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
8014    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
8015    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
8016
8017    if(ulBwp->pusch_Config)
8018    {
8019       if(ulBwp->pusch_Config->choice.setup)
8020       {
8021          puschCfg=ulBwp->pusch_Config->choice.setup;
8022          if(puschCfg->dataScramblingIdentityPUSCH)
8023          {
8024             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
8025             {
8026                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
8027                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
8028                if(dmrsUlCfg->choice.setup)
8029                {
8030                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
8031                   {
8032                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
8033                      {
8034                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
8035                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
8036                      }
8037                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
8038                   }
8039                   free(dmrsUlCfg->choice.setup);
8040                }
8041                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
8042             }
8043             free(puschCfg->dataScramblingIdentityPUSCH);
8044          }
8045          free(ulBwp->pusch_Config->choice.setup);
8046       }
8047       free(ulBwp->pusch_Config);
8048
8049       /* Free SRS-Config */
8050       if(ulBwp->srs_Config)
8051       {
8052          if(ulBwp->srs_Config->choice.setup)
8053          {
8054             srsCfg = ulBwp->srs_Config->choice.setup;
8055
8056             /* Free Resource Set to add/mod list */
8057             if(srsCfg->srs_ResourceSetToAddModList)
8058             {
8059                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
8060                if(rsrcSetList->list.array)
8061                {
8062                   rSetIdx = 0;
8063
8064                   /* Free SRS resource Id list in this SRS resource set */
8065                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
8066                   {
8067                      rsrcIdList =
8068                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
8069
8070                      if(rsrcIdList->list.array)
8071                      {
8072                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
8073                               rsrcIdx++)
8074                         {
8075                            free(rsrcIdList->list.array[rsrcIdx]);
8076                         }
8077                         free(rsrcIdList->list.array);
8078                      }
8079                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
8080                   }
8081
8082                   /* Free resource type info for this SRS resource set */
8083
8084                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
8085
8086                   /* Free memory for each resource set */
8087                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
8088                   {
8089                      free(rsrcSetList->list.array[rSetIdx]);
8090                   }
8091                   free(rsrcSetList->list.array);
8092                }
8093                free(srsCfg->srs_ResourceSetToAddModList);
8094             }
8095
8096             /* Free resource to add/modd list */
8097             if(srsCfg->srs_ResourceToAddModList)
8098             {
8099                resourceList = srsCfg->srs_ResourceToAddModList;
8100                if(resourceList->list.array)
8101                {
8102                   rsrcIdx = 0;
8103
8104                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
8105                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
8106
8107                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
8108                   {
8109                      free(resourceList->list.array[rsrcIdx]);
8110                   }
8111                   free(resourceList->list.array);
8112                }
8113                free(srsCfg->srs_ResourceToAddModList);
8114             }
8115
8116             free(ulBwp->srs_Config->choice.setup);
8117          }
8118          free(ulBwp->srs_Config);
8119       }
8120    }
8121 }
8122 /*******************************************************************
8123 *
8124 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
8125 *
8126 * @details
8127 *
8128 *    Function : freeAperDecodeinitialUplinkBWPConfig
8129 *
8130 *    Functionality: Function to free initialUplinkBWPConfig
8131 *
8132 * @params[in] UplinkConfig_t *ulCfg
8133 * @return void
8134 *
8135 * ****************************************************************/
8136
8137
8138 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
8139 {
8140    BWP_UplinkDedicated_t *ulBwp=NULLP;
8141    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
8142
8143    if(ulCfg->initialUplinkBWP)
8144    {
8145       ulBwp=ulCfg->initialUplinkBWP;
8146       if(ulCfg->firstActiveUplinkBWP_Id)
8147       {
8148          if(ulCfg->pusch_ServingCellConfig)
8149          {
8150             puschCfg=ulCfg->pusch_ServingCellConfig;
8151             if(puschCfg->choice.setup)
8152             {
8153                if(puschCfg->choice.setup->ext1)
8154                {
8155                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
8156                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
8157                   free(puschCfg->choice.setup->ext1);
8158                }
8159                free(puschCfg->choice.setup);
8160             }
8161             free(ulCfg->pusch_ServingCellConfig);
8162          }
8163          free(ulCfg->firstActiveUplinkBWP_Id);
8164       }
8165       freeAperDecodeInitialUlBWPConfig(ulBwp);
8166       free(ulCfg->initialUplinkBWP);
8167    }
8168 }
8169
8170 /*******************************************************************
8171  *
8172  * @brief Function to free DuUeCfg
8173  *
8174  * @details
8175  *
8176  *    Function : freeDuUeCfg
8177  *
8178  *    Functionality: Function to free DuUeCfg
8179  *
8180  * @params[in] DuUeCfg *ueCfg
8181  * @return void
8182  *
8183  * ****************************************************************/
8184 void freeDuUeCfg(DuUeCfg *ueCfg)
8185 {
8186    uint8_t lcIdx = 0;
8187    uint8_t arrIdx = 0;
8188    SpCellConfig_t *spCellCfg = NULLP;
8189    ServingCellConfig_t *srvCellCfg = NULLP;
8190    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8191    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
8192    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8193    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
8194    struct RLC_Config *rlcConfig = NULLP;
8195    struct LogicalChannelConfig *macLcConfig = NULLP;
8196    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
8197    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
8198    struct TAG_Config *tagConfig = NULLP;
8199    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
8200    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
8201    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
8202    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
8203
8204    if(ueCfg->ueNrCapability)
8205    {
8206       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
8207       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
8208       ueCfg->ueNrCapability = NULLP;
8209    }
8210
8211    if(ueCfg->cellGrpCfg)
8212    {
8213
8214       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8215       if(rlcBearerList)
8216       {
8217          if(rlcBearerList->list.array)
8218          {
8219             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
8220             {
8221                if(rlcBearerList->list.array[arrIdx])
8222                {
8223                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
8224                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
8225
8226                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
8227                   {
8228                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
8229                   }
8230                   if(rlcConfig)
8231                   {
8232                      if(rlcConfig->choice.am)
8233                      {
8234                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
8235                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
8236                         free(rlcConfig->choice.am);
8237                      }
8238                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
8239                   }
8240                   if(macLcConfig)
8241                   {
8242                      if(macLcConfig->ul_SpecificParameters)
8243                      {
8244                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
8245                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
8246                         free(macLcConfig->ul_SpecificParameters);
8247                      }
8248                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
8249                   }
8250                   free(rlcBearerList->list.array[arrIdx]);
8251                }
8252             }
8253             free(rlcBearerList->list.array);
8254          }
8255          free(cellGrpCfg->rlc_BearerToAddModList);
8256       }
8257
8258       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8259       if(macCellGrpCfg)
8260       {
8261          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8262          if(schedulingRequestConfig)
8263          {
8264             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8265             if(schReqList)
8266             {
8267                if(schReqList->list.array)
8268                {
8269                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
8270                   {
8271                      if(schReqList->list.array[arrIdx])
8272                      {
8273                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
8274                         free(schReqList->list.array[arrIdx]);
8275                      }
8276                   }
8277                   free(schReqList->list.array);
8278                }
8279                free(schedulingRequestConfig->schedulingRequestToAddModList);
8280             }
8281             free(macCellGrpCfg->schedulingRequestConfig);
8282          }
8283          if(macCellGrpCfg->bsr_Config)
8284          {
8285             free(macCellGrpCfg->bsr_Config);
8286          }
8287          tagConfig = macCellGrpCfg->tag_Config;
8288          if(tagConfig)
8289          {
8290             tagList = tagConfig->tag_ToAddModList;
8291             if(tagList)
8292             {
8293                if(tagList->list.array)
8294                {
8295                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
8296                   {
8297                      free(tagList->list.array[arrIdx]);
8298                   }
8299                   free(tagList->list.array);
8300                }
8301                free(tagConfig->tag_ToAddModList);
8302             }
8303             free(tagConfig);
8304          }
8305
8306          phrConfig = macCellGrpCfg->phr_Config;
8307          if(phrConfig)
8308          {
8309             free(phrConfig->choice.setup);
8310             free(phrConfig);
8311          }
8312
8313          free(macCellGrpCfg);
8314       }
8315
8316       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8317       if(phyCellGrpCfg)
8318       {
8319          free(phyCellGrpCfg->p_NR_FR1);
8320          free(phyCellGrpCfg);
8321       }
8322
8323       spCellCfg = cellGrpCfg->spCellConfig;
8324       if(spCellCfg)
8325       {
8326          if(spCellCfg->servCellIndex)
8327          {
8328             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
8329             {
8330                if(spCellCfg->spCellConfigDedicated)
8331                {
8332                   srvCellCfg = spCellCfg->spCellConfigDedicated;
8333                   if(srvCellCfg->initialDownlinkBWP)
8334                   {
8335                      dlBwp = srvCellCfg->initialDownlinkBWP;
8336                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
8337                      {
8338                         if(srvCellCfg->defaultDownlinkBWP_Id)
8339                         {
8340                            if(srvCellCfg->uplinkConfig)
8341                            {
8342
8343                               if(srvCellCfg->pdsch_ServingCellConfig)
8344                               {
8345                                  pdschCfg=
8346                                     srvCellCfg->pdsch_ServingCellConfig;
8347                                  if(pdschCfg->choice.setup)
8348                                  {
8349
8350                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
8351                                     free(pdschCfg->choice.setup);
8352                                  }
8353
8354                                  free(srvCellCfg->pdsch_ServingCellConfig);
8355                               }
8356
8357                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
8358                               free(srvCellCfg->uplinkConfig);
8359                            }
8360                            free(srvCellCfg->defaultDownlinkBWP_Id);
8361                         }
8362
8363                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
8364                      }
8365                      if(dlBwp->pdcch_Config)
8366                      {
8367                         if(dlBwp->pdsch_Config)
8368                         {
8369                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
8370                            free(dlBwp->pdsch_Config);
8371                         }
8372                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
8373                         free(dlBwp->pdcch_Config);
8374                      }
8375                      free(srvCellCfg->initialDownlinkBWP);
8376                   }
8377
8378                   free(spCellCfg->spCellConfigDedicated);
8379                }
8380                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
8381             }
8382             free(spCellCfg->servCellIndex);
8383          }
8384          free(spCellCfg);
8385       }
8386       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
8387       ueCfg->cellGrpCfg = NULLP;
8388    }
8389    if(ueCfg->ambrCfg)
8390    {
8391       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
8392    }
8393    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
8394    {
8395       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
8396    }
8397    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
8398    {
8399       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
8400    }
8401    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
8402    {
8403       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
8404    }
8405 }
8406
8407 /*******************************************************************
8408  *
8409  * @brief Function to free UecontextSetupDb
8410  *
8411  * @details
8412  *
8413  *    Function : freeF1UeDb
8414  *
8415  *    Functionality: Function to free UecontextSetupDb
8416  *
8417  * @params[in] UecontextSetupDb *
8418  * @return void
8419  *
8420  * ****************************************************************/
8421
8422 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
8423 {
8424
8425    if(f1UeDb->dlRrcMsg)
8426    {
8427       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
8428       {
8429         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
8430                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
8431       }
8432       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
8433    }
8434    freeDuUeCfg(&f1UeDb->duUeCfg);
8435    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
8436    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
8437 }
8438
8439 /*******************************************************************
8440  *
8441  * @brief Function to build Am cfg Info
8442  *
8443  * @details
8444  *
8445  *    Function : extractRlcAmCfg
8446  *
8447  *    Functionality: Function to build Am cfg Info
8448  *
8449  * @params[in] AmBearerCfg *
8450  *             void *
8451  *
8452  * @return ROK/RFAILED
8453  *
8454  * ****************************************************************/
8455
8456 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
8457 {
8458    if(rlcAmCfg)
8459    {
8460       /* UL AM */
8461       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
8462       {
8463          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
8464          /*TODO: Check the timer value when sent by real CU */
8465          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
8466          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
8467       }
8468
8469       /* DL AM */
8470       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
8471       {
8472          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
8473          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
8474          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
8475          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
8476          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
8477       }
8478    }
8479 }
8480
8481 /*******************************************************************
8482  *
8483  * @brief Function to build Um Bi Info
8484  *
8485  * @details
8486  *
8487  *    Function : extractRlcUmBiCfg
8488  *
8489  *    Functionality: Function to build Um Bi Info
8490  *
8491  * @params[in] UmBiDirBearerCfg *
8492  *             void *
8493  *
8494  * @return ROK/RFAILED
8495  *
8496  * ****************************************************************/
8497
8498 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
8499 {
8500    if(rlcBiCfg)
8501    {
8502       /* UL UM BI DIR Cfg */
8503       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
8504       {
8505          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
8506          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
8507       }
8508
8509       /* DL UM BI DIR Cfg */
8510       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
8511          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
8512    }
8513 }
8514
8515 /*******************************************************************
8516  *
8517  * @brief Function to build Um Ul Info
8518  *
8519  * @details
8520  *
8521  *    Function : extractRlcUmUlCfg
8522  *
8523  *    Functionality: Function to build Um Ul Info
8524  *
8525  * @params[in] UmUniDirUlBearerCfg *
8526  *             void *
8527  *
8528  * @return ROK/RFAILED
8529  *
8530  * ****************************************************************/
8531
8532 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
8533 {
8534    if(umUlCfg)
8535    {
8536       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
8537       {
8538          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
8539          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
8540       }
8541    }
8542 }
8543
8544 /*******************************************************************
8545  *
8546  * @brief Function to build Um Uni Dl Info
8547  *
8548  * @details
8549  *
8550  *    Function : extractRlcUmDlCfg
8551  *
8552  *    Functionality: Function to build Um Uni Dl Info
8553  *
8554  * @params[in] UmUniDirDlBearerCfg *
8555  *             void *
8556  *
8557  * @return ROK/RFAILED
8558  *
8559  * ****************************************************************/
8560 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
8561 {
8562    if(umDlCfg)
8563    {
8564       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
8565          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
8566    }
8567 }
8568
8569 /*******************************************************************
8570  *
8571  * @brief Function to extractRlcModeCfg
8572  *
8573  * @details
8574  *
8575  *    Function : extractRlcModeCfg
8576  *
8577  *    Functionality: Function to extractRlcModeCfg
8578  *
8579  * @params[in] RLC_Config_t *
8580  *             RlcBearerCfg *
8581  *             void  *
8582  * @return ROK/RFAILED
8583  *
8584  * ****************************************************************/
8585 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
8586 {
8587    if(lcCfg)
8588    {
8589       switch(rlcMode)
8590       {
8591          case RLC_AM :
8592             {
8593                if(lcCfg->choice.am)
8594                {
8595                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
8596                   if(rlcDbCfg->u.amCfg)
8597                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
8598                }
8599                break;
8600             }
8601          case RLC_UM_BI_DIRECTIONAL :
8602             {
8603                if(lcCfg->choice.um_Bi_Directional)
8604                {
8605                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8606                   if(rlcDbCfg->u.umBiDirCfg)
8607                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
8608                }
8609                break;
8610             }
8611          case RLC_UM_UNI_DIRECTIONAL_UL :
8612             {
8613                if(lcCfg->choice.um_Uni_Directional_DL)
8614                {
8615                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8616                   if(rlcDbCfg->u.umUniDirUlCfg)
8617                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
8618                }
8619                break;
8620             }
8621          case RLC_UM_UNI_DIRECTIONAL_DL :
8622             {
8623                if(lcCfg->choice.um_Uni_Directional_UL)
8624                {
8625                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8626                   if(rlcDbCfg->u.umUniDirDlCfg)
8627                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
8628                }
8629                break;
8630             }
8631          default:
8632             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
8633             break;
8634       }
8635    }
8636 }
8637
8638 /*******************************************************************
8639  *
8640  * @brief Function to extract extractUlLcCfg
8641  *
8642  * @details
8643  *
8644  *    Function : extractUlLcCfg
8645  *
8646  *    Functionality: Function to extract extractUlLcCfg
8647  *
8648  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
8649  * @return void
8650  *
8651  * ****************************************************************/
8652
8653 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
8654 {
8655    if(ulLcCfg)
8656    {
8657       if(ulLcCfg->ul_SpecificParameters)
8658       {
8659          f1UlLcCfg->priority = \
8660             ulLcCfg->ul_SpecificParameters->priority;
8661       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
8662       {
8663          f1UlLcCfg->lcGroup = \
8664            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
8665       }
8666       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
8667       {
8668          f1UlLcCfg->schReqId = \
8669            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
8670       }
8671       f1UlLcCfg->pbr = \
8672          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
8673       f1UlLcCfg->bsd = \
8674          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
8675       }
8676    }
8677 }
8678
8679 /*******************************************************************
8680 *
8681 * @brief Function to extract Snssai Cfg Info from CU
8682 *
8683 * @details
8684 *
8685 *    Function : extractDrbSnssaiCfg
8686 *
8687 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
8688 *
8689 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
8690 * @return ROK/RFAILED
8691 *
8692 * ****************************************************************/
8693
8694 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
8695 {
8696    if(!(*snssaiToBeShared))
8697    {
8698       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
8699       if(snssaiToBeShared == NULLP)
8700       {
8701          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
8702          return RFAILED;
8703       }
8704    }
8705    if(RecvSnssai)
8706    {
8707       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
8708       if(RecvSnssai->sD)
8709       {
8710          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
8711       }
8712       else
8713       {
8714          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
8715          return RFAILED;
8716       }
8717    }
8718    return ROK;
8719 }
8720
8721 /*******************************************************************
8722  *
8723  * @brief Function to procRlcLcCfg
8724  *
8725  * @details
8726  *
8727  *    Function : procRlcLcCfg
8728  *
8729  *    Functionality: Function to procRlcLcCfg
8730  *
8731  * @params[in] rbId, lcId, rbType, rlcMod
8732  *             RLC_Config_t *, RlcBearerCfg * ,
8733  * @return void
8734  *
8735  * ****************************************************************/
8736
8737 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
8738    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
8739 {
8740    DRB_Information_t *drbInfo;
8741
8742    lcCfg->rbId   = rbId;
8743    lcCfg->configType = configType;
8744
8745    if(rbType == RB_TYPE_SRB)
8746    {
8747       lcCfg->rbType = RB_TYPE_SRB;
8748       lcCfg->lcId   = rbId;
8749       lcCfg->lcType = LCH_DCCH;
8750       lcCfg->rlcMode = RLC_AM;
8751    }
8752    else if(rbType == RB_TYPE_DRB)
8753    {
8754       lcCfg->rbType = RB_TYPE_DRB;
8755       lcCfg->lcId   = lcId;
8756       lcCfg->lcType = LCH_DTCH;
8757       lcCfg->rlcMode = rlcMode;
8758    }
8759    if(f1RlcCfg) /* rlc mode config recived */
8760    {
8761       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
8762    }
8763    if(qoSInformation != NULLP)
8764    {
8765       if(qoSInformation->present == QoSInformation_PR_choice_extension)
8766       {
8767          if(qoSInformation->choice.choice_extension->value.present ==\
8768                QoSInformation_ExtIEs__value_PR_DRB_Information)
8769          {
8770             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
8771             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
8772             {
8773                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
8774                return;
8775             }
8776          }
8777       }
8778    }
8779 }
8780
8781 /*******************************************************************
8782  *
8783  * @brief Fills DrbQos Info received by CU
8784  *
8785  * @details
8786  *
8787  *    Function : extractQosInfo
8788  *
8789  *    Functionality: Fills DrbQos Info received  by CU
8790  *
8791  * @params[in] DrbQosInfo *qosToAdd,
8792  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
8793  * @return void
8794  *
8795  * ****************************************************************/
8796
8797 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
8798 {
8799    uint8_t qosCntIdx = 0;
8800    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
8801
8802    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
8803    qosToAdd->u.nonDyn5Qi.fiveQi     =\
8804                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
8805    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
8806    {
8807       qosToAdd->u.nonDyn5Qi.avgWindow = \
8808                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
8809    }
8810
8811    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
8812    {
8813       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
8814                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
8815    }
8816
8817    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
8818    {
8819       qosToAdd->u.nonDyn5Qi.priorLevel = \
8820                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
8821    }
8822    qosToAdd->ngRanRetPri.priorityLevel = \
8823                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
8824    qosToAdd->ngRanRetPri.preEmptionCap = \
8825                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
8826    qosToAdd->ngRanRetPri.preEmptionVul = \
8827                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
8828    if(qosFlowCfg->gBR_QoS_Flow_Information)
8829    {
8830       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
8831             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
8832             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
8833       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
8834             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
8835             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
8836       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
8837             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
8838             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
8839       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
8840             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
8841             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
8842    }
8843    /*Extracting PDU_SESSION_ID*/
8844    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
8845    if(qosIeExt)
8846    {
8847       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
8848       {
8849          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
8850                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
8851          {
8852             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
8853             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
8854          }
8855       }
8856    }
8857    qosToAdd->ulPduSessAggMaxBitRate = 0;
8858 }
8859
8860 /*******************************************************************
8861  *
8862  * @brief Function to extract GTP Tunnel Info from CU
8863  *
8864  * @details
8865  *
8866  *    Function : extractUpTnlInfo
8867  *
8868  *    Functionality: Function to extract GTP Tunnel Info from CU
8869  *
8870  * @params[in] F1AP message
8871  * @return ROK/RFAILED
8872  *
8873  * ****************************************************************/
8874
8875 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
8876    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
8877 {
8878    uint8_t tnlIdx;
8879    uint32_t ipv4_du = 0;
8880    GTPTunnel_t *gtpTunnel = NULLP;
8881
8882    upTnlInfo->drbId = drbId;
8883    upTnlInfo->configType = configType;
8884 #ifdef O1_ENABLE
8885    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
8886 #else
8887    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
8888 #endif
8889
8890    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
8891    {
8892       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
8893       {
8894          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
8895          {
8896             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
8897             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
8898             if(upTnlInfo->tnlCfg1 == NULLP)
8899             {
8900                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
8901                return RFAILED;
8902             }
8903             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
8904             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
8905             if(gtpTunnel->gTP_TEID.size > 0)
8906             {
8907                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
8908             }
8909          }
8910          break;
8911       }
8912    }
8913    return ROK;
8914 }
8915
8916 /*******************************************************************
8917 *
8918 * @brief Function to extract Drb Qos Cfg Info from CU
8919 *
8920 * @details
8921 *
8922 *    Function : extractDrbQosCfg
8923 *
8924 *    Functionality: Function to extract Drb Qos Cfg Info from CU
8925 *
8926 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
8927 * @return ROK/RFAILED
8928 *
8929 * ****************************************************************/
8930
8931 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
8932 {
8933    if(!macLcToAdd->drbQos)
8934    {
8935       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
8936       if(macLcToAdd->drbQos == NULLP)
8937       {
8938          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
8939          return RFAILED;
8940       }
8941
8942    }
8943    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
8944    {
8945       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
8946       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
8947    }
8948    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
8949    {
8950       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
8951       return RFAILED;
8952    }
8953    return ROK;
8954 }
8955 /*******************************************************************
8956  *
8957  * @brief Function to extract DRB info received from CU
8958  *
8959  * @details
8960  *
8961  *    Function : extractDrbCfg
8962  *
8963  *    Functionality: Function to extract DRB info received from CU
8964  *
8965  * @params[in] F1AP message
8966  * @return void
8967  *
8968  * ****************************************************************/
8969 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
8970 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
8971 {
8972    DRB_Information_t *drbInfo = NULLP;
8973
8974    if(drbItem != NULLP)
8975    {
8976       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
8977       {
8978          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8979          return RFAILED;
8980       }
8981       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8982       {
8983          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
8984          {
8985             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8986             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8987             {
8988                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8989                return RFAILED;
8990             }
8991          }
8992       }
8993    }
8994    else if(drbSetupModItem != NULLP)
8995    {
8996       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
8997       upTnlInfo) != ROK)
8998       {
8999          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
9000          return RFAILED;
9001       }
9002       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
9003       {
9004          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
9005          QoSInformation_ExtIEs__value_PR_DRB_Information)
9006          {
9007             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
9008             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
9009             {
9010                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
9011                return RFAILED;
9012             }
9013
9014          }
9015       }
9016    }
9017    else if(drbModItem != NULLP)
9018    {
9019       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
9020       upTnlInfo) != ROK)
9021       {
9022          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
9023          return RFAILED;
9024       }
9025       if(drbModItem->qoSInformation != NULLP)
9026       {
9027          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
9028          {
9029             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
9030                   QoSInformation_ExtIEs__value_PR_DRB_Information)
9031             {
9032                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
9033                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
9034                {
9035                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
9036                   return RFAILED;
9037                }
9038
9039             }
9040          }
9041       }
9042    }
9043    return ROK;
9044 }
9045
9046 /*******************************************************************
9047  *
9048  * @brief Function to extract RB info received from CU
9049  *
9050  * @details
9051  *
9052  *    Function : extractMacRbCfg
9053  *
9054  *    Functionality: Function to extract RB info received from CU
9055  *
9056  * @params[in] F1AP message
9057  * @return ROK/RFAILED
9058  *
9059  * ****************************************************************/
9060
9061 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
9062 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
9063 {
9064    if(drbCfg != NULLP)
9065    {
9066       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
9067       {
9068          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9069          return RFAILED;
9070       }
9071    }
9072    else if(drbSetupModCfg != NULLP)
9073    {
9074       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
9075       {
9076          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9077          return RFAILED;
9078       }
9079    }
9080    else if(drbModCfg != NULLP)
9081    {
9082       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
9083       {
9084          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
9085          return RFAILED;
9086       }
9087    }
9088    else
9089    {
9090       lcCfg->drbQos = NULLP;
9091       lcCfg->snssai = NULLP;
9092       if(lcCfg->lcId == SRB2_LCID)
9093          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
9094       else
9095          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
9096    }
9097    if(ulLcCfg)
9098    {
9099       lcCfg->ulLcCfgPres = true;
9100       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
9101    }
9102    else
9103       lcCfg->ulLcCfgPres = false;
9104    return ROK;
9105 }
9106
9107 /*******************************************************************
9108  *
9109  * @brief Function processing LC config info received from CU
9110  *
9111  * @details
9112  *
9113  *    Function : procMacLcCfg
9114  *
9115  *    Functionality: Function processing LC config info received from CU
9116  *
9117  * @params[in] F1AP message
9118  * @return ROK/RFAILED
9119  *
9120  * ****************************************************************/
9121
9122 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
9123 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
9124 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
9125 {
9126    uint8_t ret = ROK;
9127
9128    lcCfg->lcId = lcId;
9129    lcCfg->configType = configType;
9130    if(rbType == RB_TYPE_SRB)
9131    {
9132       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
9133    }
9134    else if(rbType == RB_TYPE_DRB)
9135    {
9136       if(drbItem != NULL)
9137         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
9138       else if(drbSetupModItem != NULL)
9139         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
9140       else if(drbModItem != NULL)
9141         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
9142    }
9143    return ret;
9144 }
9145
9146 /*******************************************************************
9147  *
9148  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
9149  *
9150  * @details
9151  *
9152  *    Function : extractRlcCfgToAddMod
9153  *
9154  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
9155  *
9156  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
9157  *             DuUeCfg Pointer
9158  * @return ROK/RFAILED
9159  *
9160  * ****************************************************************/
9161
9162 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
9163 {
9164   uint8_t idx, rbId, lcId, rlcMode, rbType;
9165   RLC_Config_t *f1RlcCfg = NULLP;
9166   LogicalChannelConfig_t *macUlLcCfg = NULLP;
9167
9168   for(idx = 0; idx < lcCfg->list.count; idx++)
9169   {
9170      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
9171      if(lcCfg->list.array[idx]->servedRadioBearer)
9172      {
9173         /* RadioBearer for SRB/DRB */
9174         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
9175         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
9176         {
9177            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
9178            rbType = RB_TYPE_SRB;
9179         }
9180         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
9181         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
9182         {
9183            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
9184            rbType = RB_TYPE_DRB;
9185         }
9186         else
9187         {
9188            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
9189            return RFAILED;
9190         }
9191         /* MAC UL LC Config */
9192         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
9193         {
9194            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
9195         }
9196      }
9197      else
9198      {
9199         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
9200         return RFAILED;
9201      }
9202      /* RLC Mode Config */
9203      if(lcCfg->list.array[idx]->rlc_Config)
9204      {
9205         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
9206         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
9207      }
9208
9209      /* Filling RLC/MAC Config*/
9210      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
9211      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
9212      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
9213      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
9214      {
9215         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
9216         return RFAILED;
9217      }
9218      (ueCfgDb->numRlcLcs)++;
9219      (ueCfgDb->numMacLcs)++;
9220      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
9221         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
9222   }
9223   //TODO: To send the failure cause in UeContextSetupRsp
9224   return ROK;
9225 }
9226
9227 /*******************************************************************
9228  *
9229  * @brief DeAlloc pdsch serv cell config info
9230  *
9231  * @details
9232  *
9233  *    Function : freeMacPdschServCellInfo
9234  *
9235  *    Functionality: DeAlloc pdsch serv cell config info
9236  *
9237  * @params[in] PdschServCellCfg pointer
9238  * @return void
9239  *
9240  * ****************************************************************/
9241
9242 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
9243 {
9244    if(pdsch->xOverhead)
9245    {
9246       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
9247    }
9248    if(pdsch->codeBlkGrpFlushInd)
9249    {
9250       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
9251    }
9252    if(pdsch->maxCodeBlkGrpPerTb)
9253    {
9254       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
9255    }
9256    if(pdsch->maxMimoLayers)
9257    {
9258       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
9259    }
9260 }
9261
9262 /*******************************************************************
9263  *
9264  * @brief Free Serving cell Info
9265  *
9266  * @details
9267  *
9268  *    Function : freeMacServingCellInfo
9269  *
9270  *    Functionality: Free Serving cell Info
9271  *
9272  * @params[in] ServCellCfgInfo *srvCellCfg
9273  * @return void
9274  *
9275  * ****************************************************************/
9276 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
9277 {
9278    uint8_t timeDomRsrcIdx;
9279
9280    if(srvCellCfg->initDlBwp.pdschPresent)
9281    {
9282       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
9283       {
9284          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
9285             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
9286       }
9287    }
9288
9289    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
9290    if(srvCellCfg->bwpInactivityTmr)
9291    {
9292       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9293    }
9294
9295    if(srvCellCfg->initUlBwp.pucchPresent)
9296    {
9297       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9298    }
9299 }
9300
9301 /*******************************************************************
9302  *
9303  * @brief Free cell Grp Cfg Info
9304  *
9305  * @details
9306  *
9307  *    Function : freeUeReCfgCellGrpInfo
9308  *
9309  *    Functionality: Free cell Grp Cfg Info
9310  *
9311  * @params[in] MacUeCfg*  duUeCfg
9312  * @return void
9313  *
9314  * ****************************************************************/
9315
9316 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
9317 {
9318    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
9319 }
9320
9321 /*******************************************************************
9322  *
9323  * @brief Fills Reconfig SchReqReConfig
9324  *
9325  * @details
9326  *
9327  *    Function : extractSchReqReConfig
9328  *
9329  *    Functionality: Fills Reconfig SchReqReConfig
9330  *
9331  * @params[in] SchedulingRequestConfig_t *cuSchedReq
9332  *             SchedReqCfg*  macSchedReq
9333  * @return void
9334  *
9335  * ****************************************************************/
9336 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
9337 {
9338    uint8_t schReqIdx = 0;
9339    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
9340    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
9341
9342    if(cuSchedReq->schedulingRequestToAddModList)
9343    {
9344       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
9345       if(schReqListToAdd->list.count)
9346       {
9347          macSchedReq->addModListCount = schReqListToAdd->list.count;
9348          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
9349          {
9350             macSchedReq->addModList[schReqIdx].schedReqId = \
9351                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
9352             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
9353                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
9354             macSchedReq->addModList[schReqIdx].srTransMax    =\
9355                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
9356          }
9357       }
9358    }
9359    /* Scheduling Req To release */
9360    if(cuSchedReq->schedulingRequestToReleaseList)
9361    {
9362       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
9363       if(schReqListToRel->list.count)
9364       {
9365          macSchedReq->relListCount = schReqListToRel->list.count;
9366          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
9367          {
9368             macSchedReq->relList[schReqIdx] = \
9369                *schReqListToRel->list.array[schReqIdx];
9370          }
9371       }
9372    }
9373 }
9374
9375 /*******************************************************************
9376  *
9377  * @brief Fills TagReconfig
9378  *
9379  * @details
9380  *
9381  *    Function : extractTagReconfig
9382  *
9383  *    Functionality: Fills extractTagReconfig
9384  *
9385  * @params[in] TAG_Config_t *cuTagCfg
9386  *             TagCfg *macTagCfg
9387  * @return void
9388  *
9389  * ****************************************************************/
9390
9391 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
9392 {
9393   uint8_t tagIdx = 0;
9394   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
9395   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
9396
9397   /* Tag config to AddMod */
9398   if(cuTagCfg->tag_ToAddModList)
9399   {
9400      tagListToAddMod = cuTagCfg->tag_ToAddModList;
9401      if(tagListToAddMod->list.count)
9402      {
9403         macTagCfg->addModListCount = tagListToAddMod->list.count;
9404         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
9405         {
9406            macTagCfg->addModList[tagIdx].tagId =\
9407               tagListToAddMod->list.array[tagIdx]->tag_Id;
9408            macTagCfg->addModList[tagIdx].timeAlignTimer = \
9409
9410               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
9411         }
9412      }
9413   }
9414   /* Tag config to release */
9415   if(cuTagCfg->tag_ToReleaseList)
9416   {
9417      tagListToRel = cuTagCfg->tag_ToReleaseList;
9418      if(tagListToRel->list.count)
9419      {
9420         macTagCfg->relListCount = tagListToRel->list.count;
9421         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
9422         {
9423            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
9424         }
9425      }
9426   }
9427 }
9428
9429 /*******************************************************************
9430  *
9431  * @brief Fills PdcchCfg received by CU
9432  *
9433  * @details
9434  *
9435  *    Function : extractPdcchCfg
9436  *
9437  *    Functionality: Fills PdcchCfg received  by CU
9438  *
9439  * @params[in] PDCCH_Config_t *cuPdcchCfg,
9440  *             PdcchConfig *duPdcchCfg
9441  * @return void
9442  *
9443  * ****************************************************************/
9444
9445 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
9446 {
9447    uint8_t cRsetIdx = 0;
9448    uint8_t srchSpcIdx = 0;
9449
9450    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
9451    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
9452    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
9453    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
9454
9455
9456    /* Control Resource Set To Add/Mod List */
9457    if(cuPdcchCfg->controlResourceSetToAddModList)
9458    {
9459       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
9460       if(cRsetToAddModList->list.count)
9461       {
9462          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
9463          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
9464          {
9465             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
9466                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
9467             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
9468                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
9469             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
9470                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
9471                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
9472
9473             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
9474                 cRsetToAddModList->list.array[cRsetIdx]->duration;
9475
9476             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
9477                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
9478             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
9479             {
9480                //TODO: handle the case for Interleaved
9481             }
9482             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
9483                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
9484             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
9485             {
9486                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
9487                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
9488             }
9489          }
9490       }
9491    }
9492    /* Control Resource Set To Release List */
9493    if(cuPdcchCfg->controlResourceSetToReleaseList)
9494    {
9495       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
9496       if(cRsetToRelList->list.count)
9497       {
9498          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
9499          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
9500          {
9501             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
9502          }
9503       }
9504    }
9505
9506    /* Search space To Add/Mod List */
9507    if(cuPdcchCfg->searchSpacesToAddModList)
9508    {
9509       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
9510       if(srchSpcToAddModList->list.count)
9511       {
9512          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
9513          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
9514          {
9515             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
9516                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
9517             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
9518                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
9519             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
9520             {
9521                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
9522                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
9523             }
9524             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
9525             {
9526                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
9527                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
9528             }
9529             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
9530             {
9531                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
9532                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
9533                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
9534                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
9535                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
9536                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
9537
9538                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
9539                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
9540
9541                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
9542                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
9543             }
9544             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
9545             {
9546                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
9547                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
9548                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
9549                {
9550                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
9551                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
9552                }
9553
9554             }
9555          }
9556       }
9557    }
9558    /* Search space To Rel List */
9559    if(cuPdcchCfg->searchSpacesToReleaseList)
9560    {
9561       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
9562       if(srchSpcToRelList->list.count)
9563       {
9564          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
9565          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
9566          {
9567             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
9568                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
9569          }
9570       }
9571    }
9572 }
9573
9574 /*******************************************************************
9575  *
9576  * @brief Fills PdschCfg received by CU
9577  *
9578  * @details
9579  *
9580  *    Function : extractPdschCfg
9581  *
9582  *    Functionality: Fills PdschCfg received  by CU
9583  *
9584  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
9585  *                   which we have stored in F1UeContextSetupDb,
9586  *             PdschConfig *macPdschCfg = Used to Store the information which
9587  *                   needs to send in other layer, as well as this can be the variable
9588  *                   which stores the information in DuCb,
9589  *             PdschConfig *storedPdschCfg =  Null in case of sending the
9590  *                   information to other layer else it will have stored pdsch
9591  *                   configuration in copyOfmacUeCfg.
9592  * @return void
9593  *
9594  * ****************************************************************/
9595
9596 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
9597 {
9598    uint8_t timeDomIdx;
9599    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
9600
9601    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9602    {
9603       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
9604             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
9605       {
9606          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
9607          {
9608             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
9609                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
9610          }
9611       }
9612    }
9613    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
9614    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
9615    {
9616       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
9617       if(timeDomAlloc->present ==\
9618             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
9619       {
9620          if(timeDomAlloc->choice.setup)
9621          {
9622             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
9623             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
9624             {
9625                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
9626                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
9627                {
9628                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
9629                   {
9630                      if(storedPdschCfg)
9631                      {
9632                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
9633                         {
9634                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
9635                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
9636                         }
9637                         else
9638                         {
9639                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
9640                         }
9641                      }
9642                      else
9643                      {
9644                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
9645                      }
9646                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
9647                      {
9648                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
9649                         return;
9650                      }
9651                   }
9652                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
9653                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
9654                }
9655                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
9656                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
9657                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
9658                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
9659             }
9660          }
9661       }
9662    }
9663    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
9664    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
9665       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
9666    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
9667    {
9668       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
9669       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
9670       {
9671          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
9672          {
9673             macPdschCfg->bundlingInfo.StaticBundling.size = \
9674                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
9675          }
9676       }
9677    }
9678    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
9679    {
9680       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
9681    }
9682
9683 }
9684
9685 /*******************************************************************
9686  *
9687  * @brief Fills PdschServingCellCfg received by CU
9688  *
9689  * @details
9690  *
9691  *    Function : extractPdschServingCellCfg
9692  *
9693  *    Functionality: Fills PdschCfg received  by CU
9694  *
9695  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
9696  *             PdschServCellCfg *macUePdschSrvCellCfg
9697  * @return ROK/RFAILED
9698  *
9699  * ****************************************************************/
9700
9701 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
9702 {
9703    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
9704    {
9705       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
9706       {
9707          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
9708          {
9709             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
9710                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
9711          }
9712          else
9713          {
9714             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
9715             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
9716             {
9717                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
9718                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
9719             }
9720             else
9721             {
9722                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
9723                return RFAILED;
9724             }
9725          }
9726          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
9727          {
9728             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
9729                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
9730          }
9731          else
9732          {
9733             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
9734             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
9735             {
9736                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
9737                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
9738             }
9739             else
9740             {
9741                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
9742                return RFAILED;
9743             }
9744          }
9745       }
9746    }
9747    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
9748    {
9749       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
9750    }
9751    if(cuPdschSrvCellCfg->ext1)
9752    {
9753       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
9754       {
9755         if(macUePdschSrvCellCfg->maxMimoLayers)
9756         {
9757            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
9758         }
9759         else
9760         {
9761            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
9762            if(macUePdschSrvCellCfg->maxMimoLayers)
9763            {
9764               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
9765            }
9766            else
9767            {
9768               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
9769               return RFAILED;
9770            }
9771         }
9772       }
9773    }
9774    if(cuPdschSrvCellCfg->xOverhead)
9775    {
9776       if(macUePdschSrvCellCfg->xOverhead)
9777       {
9778          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
9779       }
9780       else
9781       {
9782          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
9783          if(macUePdschSrvCellCfg->xOverhead)
9784          {
9785             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
9786          }
9787          else
9788          {
9789             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
9790             return RFAILED;
9791          }
9792       }
9793    }
9794    return ROK;
9795 }
9796
9797 /*******************************************************************
9798  *
9799  * @brief Fills PuschCfg received by CU
9800  *
9801  * @details
9802  *
9803  *    Function : extractPuschCfg
9804  *
9805  *    Functionality: Fills PuschCfg received  by CU
9806  *
9807  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
9808  *             PuschCfg *macPuschCfg
9809  * @return void
9810  *
9811  * ****************************************************************/
9812
9813 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
9814 {
9815    uint8_t timeDomIdx = 0;
9816    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
9817    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
9818
9819    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
9820    {
9821       if(cuPuschCfg->choice.setup)
9822       {
9823          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
9824          {
9825              macPuschCfg->dataScramblingId = \
9826                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
9827          }
9828          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
9829          {
9830             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
9831             {
9832                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
9833                {
9834                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
9835                   if(dmrsUlCfg->dmrs_AdditionalPosition)
9836                   {
9837                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
9838                         *(dmrsUlCfg->dmrs_AdditionalPosition);
9839                   }
9840                   if(dmrsUlCfg->transformPrecodingDisabled)
9841                   {
9842                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
9843                      {
9844                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
9845                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
9846                      }
9847                   }
9848                }
9849             }
9850          }
9851          /*Res Alloc Type for UL */
9852          if(cuPuschCfg->choice.setup->resourceAllocation)
9853          {
9854             macPuschCfg->resourceAllocType = \
9855                cuPuschCfg->choice.setup->resourceAllocation;
9856          }
9857          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
9858          {
9859             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
9860             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
9861             {
9862                if(timeDomAllocList->choice.setup)
9863                {
9864                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
9865                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
9866                   {
9867                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
9868                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
9869                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
9870                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
9871                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
9872                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
9873                   }
9874                }
9875             }
9876          }
9877          if(cuPuschCfg->choice.setup->transformPrecoder)
9878             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
9879       }
9880    }
9881 }
9882
9883 /*******************************************************************
9884  *
9885  * @brief Function to fill pucch Power Control
9886  *
9887  * @details
9888  *
9889  *    Function : extractPucchPowerControl
9890  *
9891  *    Functionality: Function to fill pucch Power Control
9892  *
9893  * @params[in] PucchPowerControl *pwrCtrl,
9894  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
9895  * @return void
9896  *
9897  * ****************************************************************/
9898
9899 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
9900 {
9901    uint8_t arrIdx;
9902
9903    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
9904       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
9905    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
9906       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
9907    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
9908       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
9909    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
9910       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
9911    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
9912       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
9913    if(cuPwrCtrlCfg->p0_Set)
9914    {
9915       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
9916       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
9917       {
9918          pwrCtrl->p0Set[arrIdx].p0PucchId =\
9919             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
9920          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
9921             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
9922       }
9923    }
9924    if(cuPwrCtrlCfg->pathlossReferenceRSs)
9925    {
9926       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
9927       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
9928       {
9929          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
9930             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
9931       }
9932    }
9933 }
9934
9935  /*******************************************************************
9936  *
9937  * @brief Function to extractResrcSetToAddModList sent by CU
9938  *
9939  * @details
9940  *
9941  *    Function : extractResrcSetToAddModList
9942  *
9943  *    Functionality: Fucntion to extractResrcSetToAddModList
9944  *
9945  * @params[in] PucchResrcSetCfg pointer,
9946  *             struct PUCCH_Config__resourceSetToAddModList pointer
9947  * @return void
9948  *
9949  * ****************************************************************/
9950
9951 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
9952 {
9953    uint8_t arrIdx, rsrcListIdx;
9954
9955    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
9956    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
9957    {
9958       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
9959          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
9960       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
9961          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
9962       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
9963       {
9964          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
9965             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
9966       }
9967
9968       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
9969       {
9970          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
9971             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
9972       }
9973       else
9974       {
9975          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
9976       }
9977    }
9978 }/* End of extractResrcSetToAddModList */
9979
9980 /*******************************************************************
9981  *
9982  * @brief Fills extractResrcToAddModList sent by CU
9983  *
9984  * @details
9985  *
9986  *    Function : extractResrcToAddModList
9987  *
9988  *    Functionality: Fills extractResrcToAddModList
9989  *
9990  * @params[in] PucchResrcCfg pointer,
9991  *             struct PUCCH_Config__resourceToAddModList pointer
9992  * @return ROk/RFAILED
9993  *
9994  * ****************************************************************/
9995
9996 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
9997 {
9998    uint8_t arrIdx;
9999
10000    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
10001    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
10002    {
10003       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
10004         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
10005       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
10006         cuResrcList->list.array[arrIdx]->startingPRB;
10007       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
10008       {
10009          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
10010            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
10011       }
10012       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
10013       {
10014          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
10015            *cuResrcList->list.array[arrIdx]->secondHopPRB;
10016       }
10017       /* PUCCH RSRC FORMAT */
10018       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
10019       {
10020          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
10021          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
10022          {
10023             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
10024             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
10025             {
10026                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
10027                return RFAILED;
10028             }
10029             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
10030                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
10031             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
10032                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
10033             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
10034                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
10035          }
10036       }
10037       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
10038       {
10039          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
10040          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
10041          {
10042             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
10043             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
10044             {
10045                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
10046                return RFAILED;
10047             }
10048             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
10049                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
10050             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
10051                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
10052             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
10053                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
10054             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
10055                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
10056          }
10057       }
10058       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
10059       {
10060          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
10061          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
10062          {
10063             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
10064             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
10065             {
10066                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
10067                return RFAILED;
10068             }
10069             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
10070                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
10071             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
10072                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
10073             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
10074                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
10075          }
10076       }
10077       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
10078       {
10079          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
10080          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
10081          {
10082             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
10083             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
10084             {
10085                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
10086                return RFAILED;
10087             }
10088             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
10089                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
10090             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
10091                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
10092             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
10093                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
10094          }
10095       }
10096       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
10097       {
10098          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
10099          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
10100          {
10101             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
10102             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
10103             {
10104                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
10105                return RFAILED;
10106             }
10107             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
10108                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
10109             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
10110                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
10111             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
10112                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
10113             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
10114                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
10115          }
10116       }
10117    }
10118    return ROK;
10119
10120 }/* End of extractResrcToAddModList */
10121
10122 /*******************************************************************
10123  *
10124  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
10125  *
10126  * @details
10127  *
10128  *    Function : fillPucchSchedReqPeriodAndOffset
10129  *
10130  *    Functionality: To fillPucchSchedReqPeriodAndOffset
10131  *
10132  * @params[in] macPeriodicty,
10133  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
10134  * @return void
10135  *
10136  * ****************************************************************/
10137
10138 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
10139    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
10140 {
10141    macPeriodicty = cuPeriodicty->present;
10142    switch(macPeriodicty)
10143    {
10144       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
10145          {
10146             macOffset     = cuPeriodicty->choice.sym2;
10147             break;
10148          }
10149       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
10150          {
10151             macOffset     = cuPeriodicty->choice.sym6or7;
10152             break;
10153          }
10154       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
10155          {
10156             macOffset     = cuPeriodicty->choice.sl1;
10157             break;
10158          }
10159       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
10160          {
10161             macOffset = cuPeriodicty->choice.sl2;
10162             break;
10163          }
10164       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
10165          {
10166             macOffset = cuPeriodicty->choice.sl4;
10167             break;
10168          }
10169       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
10170          {
10171             macOffset = cuPeriodicty->choice.sl5;
10172             break;
10173          }
10174       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
10175          {
10176             macOffset = cuPeriodicty->choice.sl8;
10177             break;
10178          }
10179       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
10180          {
10181             macOffset = cuPeriodicty->choice.sl10;
10182             break;
10183          }
10184       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
10185          {
10186             macOffset = cuPeriodicty->choice.sl16;
10187             break;
10188          }
10189       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
10190          {
10191             macOffset = cuPeriodicty->choice.sl20;
10192             break;
10193          }
10194       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
10195          {
10196             macOffset = cuPeriodicty->choice.sl40;
10197             break;
10198          }
10199       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
10200          {
10201             macOffset = cuPeriodicty->choice.sl80;
10202             break;
10203          }
10204       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
10205          {
10206             macOffset = cuPeriodicty->choice.sl160;
10207             break;
10208          }
10209       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
10210          {
10211             macOffset = cuPeriodicty->choice.sl320;
10212             break;
10213          }
10214       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
10215          {
10216             macOffset = cuPeriodicty->choice.sl640;
10217             break;
10218          }
10219       default :
10220          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
10221    }
10222 }
10223
10224 /*******************************************************************
10225  *
10226  * @brief Function to extractPucchFormatCfg sent by CU
10227  *
10228  * @details
10229  *
10230  *    Function : extractPucchFormatCfg
10231  *
10232  *    Functionality: Function to extractPucchFormatCfg
10233  *
10234  * @params[in] PucchFormatCfg pointer,
10235  *             PUCCH_FormatConfig_t pointer
10236  * @return void
10237  *
10238  * ****************************************************************/
10239
10240 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
10241  {
10242     if(cuFormatCfg->interslotFrequencyHopping)
10243        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
10244     if(cuFormatCfg->additionalDMRS)
10245        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
10246     if(cuFormatCfg->maxCodeRate)
10247        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
10248     if(cuFormatCfg->nrofSlots)
10249        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
10250     if(cuFormatCfg->pi2BPSK)
10251        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
10252     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
10253        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
10254  }/* End of extractPucchFormatCfg */
10255
10256 /*******************************************************************
10257  *
10258  * @brief Function to extractSchedReqCfgToAddMod sent by CU
10259  *
10260  * @details
10261  *
10262  *    Function : extractSchedReqCfgToAddMod
10263  *
10264  *    Functionality: Function to extractSchedReqCfgToAddMod
10265  *
10266  * @params[in] PucchSchedReqCfg pointer,
10267  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
10268  * @return void
10269  *
10270  * ****************************************************************/
10271
10272 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
10273 {
10274    uint8_t arrIdx;
10275
10276    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
10277    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
10278    {
10279       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
10280          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
10281       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
10282          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
10283       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
10284       {
10285          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
10286             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
10287       }
10288       if(cuSchedReqList->list.array[arrIdx]->resource)
10289       {
10290          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
10291             *cuSchedReqList->list.array[arrIdx]->resource;
10292       }
10293    }
10294
10295 }/* End of extractSchedReqCfgToAddMod */
10296
10297  /*******************************************************************
10298  *
10299  * @brief Fills PucchCfg received by CU
10300  *
10301  * @details
10302  *
10303  *    Function : extractPucchCfg
10304  *
10305  *    Functionality: Fills PucchCfg received  by CU
10306  *
10307  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
10308  *                is send by CU, which we have stored in F1UeContextSetupDb,
10309  *             PucchCfg *macPucchCfg = Used to Store the information which
10310  *                needs to send in other layer, as well as this can be the variable
10311  *                which stores the information in DuCb,
10312  *             PucchCfg *storedPucchCfg = Null in case of sending the
10313  *                information to other layer else it will have Pucch Cfg which
10314  *                we have stored in copyOfmacUeCfg.
10315  * @return ROK/RFAILED
10316  *
10317  * ****************************************************************/
10318
10319 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
10320 PucchCfg *storedPucchCfg)
10321 {
10322    uint8_t arrIdx;
10323
10324    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
10325    {
10326       if(cuPucchCfg->choice.setup)
10327       {
10328          /* Resource Set Cfg */
10329          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
10330          {
10331             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
10332             if(macPucchCfg->resrcSet == NULLP)
10333             {
10334                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
10335                return RFAILED;
10336             }
10337             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
10338             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
10339          }
10340
10341          /* Resource Cfg */
10342          if(cuPucchCfg->choice.setup->resourceToAddModList)
10343          {
10344             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
10345             if(macPucchCfg->resrc == NULLP)
10346             {
10347                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
10348                return RFAILED;
10349             }
10350             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
10351             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
10352          }
10353
10354          /* Format 1 Cfg */
10355          if(cuPucchCfg->choice.setup->format1)
10356          {
10357             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
10358             if(macPucchCfg->format1 == NULLP)
10359             {
10360                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
10361                return RFAILED;
10362             }
10363             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
10364             extractPucchFormatCfg(macPucchCfg->format1,\
10365                cuPucchCfg->choice.setup->format1->choice.setup);
10366          }
10367
10368          /* Format 2 Cfg */
10369          if(cuPucchCfg->choice.setup->format2)
10370          {
10371             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
10372             if(macPucchCfg->format2 == NULLP)
10373             {
10374                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
10375                return RFAILED;
10376             }
10377             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
10378             extractPucchFormatCfg(macPucchCfg->format2,\
10379                cuPucchCfg->choice.setup->format2->choice.setup);
10380          }
10381
10382          /* Format 3 Cfg */
10383          if(cuPucchCfg->choice.setup->format3)
10384          {
10385             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
10386             if(macPucchCfg->format3 == NULLP)
10387             {
10388                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
10389                return RFAILED;
10390             }
10391             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
10392             extractPucchFormatCfg(macPucchCfg->format3,\
10393                cuPucchCfg->choice.setup->format3->choice.setup);
10394          }
10395
10396          /* Format 4 Cfg */
10397          if(cuPucchCfg->choice.setup->format4)
10398          {
10399             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
10400             if(macPucchCfg->format4 == NULLP)
10401             {
10402                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
10403                return RFAILED;
10404             }
10405             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
10406             extractPucchFormatCfg(macPucchCfg->format4,\
10407                cuPucchCfg->choice.setup->format4->choice.setup);
10408          }
10409
10410          /* Sched Req List */
10411          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
10412          {
10413             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
10414             if(macPucchCfg->schedReq == NULLP)
10415             {
10416                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
10417                return RFAILED;
10418             }
10419             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
10420             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
10421             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
10422          }
10423
10424          /*TODO: Add support for  Spatial Info */
10425
10426          /* MultiCsiCfg */
10427          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
10428          {
10429             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
10430             if(macPucchCfg->multiCsiCfg == NULLP)
10431             {
10432                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
10433                return RFAILED;
10434             }
10435             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
10436             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
10437             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
10438             {
10439                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
10440                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
10441             }
10442          }
10443
10444          /* Dl_DataToUL_ACK */
10445          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
10446     {
10447        if(storedPucchCfg)
10448        {
10449           if(storedPucchCfg->dlDataToUlAck)
10450           {
10451              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
10452           }
10453           else
10454           {
10455             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10456           }
10457        }
10458        else
10459        {
10460           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10461        }
10462        if(macPucchCfg->dlDataToUlAck == NULLP)
10463        {
10464           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
10465           return RFAILED;
10466        }
10467        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
10468        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
10469        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
10470        {
10471           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
10472           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
10473        }
10474          }
10475
10476          /* Power Control */
10477          if(cuPucchCfg->choice.setup->pucch_PowerControl)
10478          {
10479             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
10480             if(macPucchCfg->powerControl == NULLP)
10481             {
10482                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
10483                return RFAILED;
10484             }
10485             extractPucchPowerControl(macPucchCfg->powerControl,\
10486                cuPucchCfg->choice.setup->pucch_PowerControl);
10487          }
10488       }
10489    }
10490    return ROK;
10491 }
10492
10493 /*******************************************************************
10494  *
10495  * @brief Fills ServingCellReconfig received by CU
10496  *
10497  * @details
10498  *
10499  *    Function : extractSpCellDedicatedCfg
10500  *
10501  *    Functionality: Fills ServingCellReconfig received  by CU
10502  *
10503  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
10504  *                  CU, which we have stored in F1UeContextSetupDb,
10505  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
10506  *                  which  needs to send in other layer, as well as this can be the
10507  *                  variable which stores the information in DuCb,
10508  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
10509  *                  information to other layer else it will have ServCellCfgInfo which
10510  *                  we have stored in copyOfmacUeCfg.
10511  * @return ROK/RFAILD
10512  *
10513  * ****************************************************************/
10514 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
10515 ServCellCfgInfo *storedSrvCellCfg)
10516 {
10517    uint8_t ret = ROK;
10518    BWP_DownlinkDedicated_t *dlBwp = NULLP;
10519    BWP_UplinkDedicated_t   *ulBwp = NULLP;
10520
10521    if(cuSrvCellCfg->initialDownlinkBWP)
10522    {
10523       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
10524       if(dlBwp->pdcch_Config)
10525       {
10526          if(dlBwp->pdcch_Config->choice.setup)
10527          {
10528             macSrvCellCfg->initDlBwp.pdcchPresent = true;
10529             if(storedSrvCellCfg)
10530             {
10531                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
10532                {
10533                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10534                }
10535                else
10536                {
10537                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10538                }
10539             }
10540             else
10541             {
10542                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
10543             }
10544          }
10545       }
10546       if(dlBwp->pdsch_Config)
10547       {
10548          if(dlBwp->pdsch_Config->choice.setup)
10549          {
10550             macSrvCellCfg->initDlBwp.pdschPresent = true;
10551
10552             if(storedSrvCellCfg)
10553             {
10554                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
10555                {
10556                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
10557                }
10558                else
10559                {
10560                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
10561                         &storedSrvCellCfg->initDlBwp.pdschCfg);
10562                }
10563             }
10564             else
10565             {
10566                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
10567             }
10568          }
10569       }
10570    }
10571    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
10572       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
10573    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
10574       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
10575    if(cuSrvCellCfg->bwp_InactivityTimer)
10576    {
10577       if(macSrvCellCfg->bwpInactivityTmr)
10578       {
10579          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
10580       }
10581       else
10582       {
10583          macSrvCellCfg->bwpInactivityTmr = NULLP;
10584          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10585          if(macSrvCellCfg->bwpInactivityTmr)
10586          {
10587             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
10588          }
10589          else
10590          {
10591             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
10592             return RFAILED;
10593          }
10594       }
10595    }
10596    if(cuSrvCellCfg->pdsch_ServingCellConfig)
10597    {
10598       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
10599       {
10600          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
10601          if(ret == RFAILED)
10602          {
10603             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
10604             return RFAILED;
10605          }
10606       }
10607    }
10608    if(cuSrvCellCfg->uplinkConfig)
10609    {
10610       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
10611       {
10612          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
10613          if(ulBwp->pusch_Config)
10614          {
10615             macSrvCellCfg->initUlBwp.puschPresent = true;
10616             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
10617          }
10618          if(ulBwp->pucch_Config)
10619          {
10620             macSrvCellCfg->initUlBwp.pucchPresent = true;
10621             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
10622             if(storedSrvCellCfg)
10623             {
10624                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
10625                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
10626                else
10627                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
10628                   &storedSrvCellCfg->initUlBwp.pucchCfg);
10629             }
10630             else
10631             {
10632                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
10633             }
10634          }
10635       }
10636       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
10637          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
10638    }
10639    return ret;
10640 }
10641 /*******************************************************************
10642  *
10643  * @brief Fills Reconfig Cell group Info received by CU
10644  *
10645  * @details
10646  *
10647  *    Function : extractUeReCfgCellInfo
10648  *
10649  *    Functionality: Fills Reconfig Cell group Info received by CU
10650  *
10651  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
10652  *                       is send by CU, which we have stored in F1UeContextSetupDb
10653  *             MacUeCfg *MacUeCfg = Used to Store the information,
10654  *                      which needs to send in other layer, as well as this can be
10655  *                      the variable which stores the information in DuCb,
10656  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
10657  *                      information to other layer else it will have copyOfmacUeCfg
10658  *                      which we have stored in F1UeContextSetupDb.
10659  *
10660  * @return ROK/RFAILED
10661  *
10662  * ****************************************************************/
10663 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
10664 {
10665    uint8_t ret = ROK;
10666    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
10667    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
10668    SpCellConfig_t            *spcellCfg = NULLP;
10669    ServingCellConfig_t       *servCellCfg = NULLP;
10670
10671    if(cellGrp)
10672    {
10673       /* Fill MacCell Group Reconfig  */
10674       if(cellGrp->mac_CellGroupConfig)
10675       {
10676          macUeCfg->macCellGrpCfgPres = true;
10677          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
10678          if(macCellGroup->schedulingRequestConfig)
10679          {
10680             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
10681          }
10682          if(macCellGroup->tag_Config)
10683          {
10684             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
10685          }
10686          if(macCellGroup->bsr_Config)
10687          {
10688             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
10689             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
10690             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
10691             {
10692                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
10693                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
10694             }
10695          }
10696          if(macCellGroup->phr_Config)
10697          {
10698             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
10699             {
10700                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
10701                if(macCellGroup->phr_Config->choice.setup)
10702                {
10703                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
10704                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
10705                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
10706                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
10707                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
10708                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
10709                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
10710                   macCellGroup->phr_Config->choice.setup->multiplePHR;
10711                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
10712                   macCellGroup->phr_Config->choice.setup->dummy;
10713                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
10714                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
10715                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
10716                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
10717                }
10718             }
10719          }
10720       }
10721       /* Fill Physical Cell Group Reconfig */
10722       if(cellGrp->physicalCellGroupConfig)
10723       {
10724          macUeCfg->phyCellGrpCfgPres = true;
10725          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
10726          if(phyCellGrpCfg->p_NR_FR1)
10727          {
10728             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
10729                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
10730          }
10731          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
10732       }
10733       /* Fill SpCell Reconfig */
10734       if(cellGrp->spCellConfig)
10735       {
10736          macUeCfg->spCellCfgPres = true;
10737          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
10738          if(spcellCfg->servCellIndex)
10739          {
10740             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
10741          }
10742          /* Fill Serving cell Reconfig info */
10743          if(cellGrp->spCellConfig->spCellConfigDedicated)
10744          {
10745             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
10746             if(storedMacUeCfg)
10747             {
10748                if(!storedMacUeCfg->spCellCfgPres)
10749                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
10750                else
10751                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
10752                         &storedMacUeCfg->spCellCfg.servCellCfg);
10753             }
10754             else
10755             {
10756                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
10757             }
10758             if(ret == RFAILED)
10759             {
10760                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
10761             }
10762          }
10763       }
10764    }
10765    return ret;
10766 }
10767 /*******************************************************************
10768 *
10769 * @brief free the memory allocated by decoder
10770 *
10771 * @details
10772 *
10773 *    Function : freeAperDecodeNrcgi
10774 *
10775 *    Functionality: Free Nrcgi values
10776 *
10777 * @params[in] NRCGI_t *nrcgi
10778 * @return void
10779 *
10780 * ****************************************************************/
10781
10782
10783 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
10784 {
10785     if(nrcgi->pLMN_Identity.buf != NULLP)
10786     {
10787        free(nrcgi->pLMN_Identity.buf);
10788     }
10789     if(nrcgi->nRCellIdentity.buf != NULLP)
10790     {
10791        free(nrcgi->nRCellIdentity.buf);
10792     }
10793 }
10794 /*******************************************************************
10795 *
10796 * @brief free the memory allocated by decoder
10797 *
10798 * @details
10799 *
10800 *    Function : freeAperDecodeCuToDuInfo
10801 *
10802 *    Functionality:  Free Cu To Du Information
10803 *
10804 * @params[in] CUtoDURRCInformation_t *rrcMsg
10805 * @return void
10806 *
10807 * ****************************************************************/
10808
10809
10810 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
10811 {
10812    uint8_t ieIdx =0;
10813    uint8_t arrIdx =0;
10814
10815    if(rrcMsg->uE_CapabilityRAT_ContainerList)
10816    {
10817       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
10818          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
10819       free(rrcMsg->uE_CapabilityRAT_ContainerList);
10820    }
10821
10822    if(rrcMsg->iE_Extensions)
10823    {
10824       if(rrcMsg->iE_Extensions->list.array)
10825       {
10826          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
10827          {
10828             if(rrcMsg->iE_Extensions->list.array[ieIdx])
10829             {
10830                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
10831                {
10832                   case ProtocolIE_ID_id_CellGroupConfig:
10833                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
10834                      {
10835                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
10836                      }
10837                      break;
10838                   default:
10839                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
10840                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
10841                      break;
10842                }
10843             }
10844          }
10845          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
10846          {
10847             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
10848          }
10849          free(rrcMsg->iE_Extensions->list.array);
10850
10851       }
10852
10853       free(rrcMsg->iE_Extensions);
10854    }
10855 }
10856 /*******************************************************************
10857 *
10858 * @brief free the memory allocated by decoder
10859 *
10860 * @details
10861 *
10862 *    Function : freeAperDecodeSplCellList
10863 *
10864 *    Functionality: Free Spl Cell List
10865                     where memory allocated by aper_decoder
10866 *
10867 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
10868 * @return void
10869 *
10870 * ****************************************************************/
10871
10872
10873 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
10874 {
10875     uint8_t  cellIdx =0;
10876
10877     if(spCellLst->list.array != NULLP)
10878     {
10879        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
10880        {
10881           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
10882           {
10883              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
10884           }
10885           if(spCellLst->list.array[cellIdx]!=NULLP)
10886           {
10887              free(spCellLst->list.array[cellIdx]);
10888           }
10889        }
10890        free(spCellLst->list.array);
10891     }
10892 }
10893 /*******************************************************************
10894 *
10895 * @brief free the memory allocated by decoder
10896 *
10897 * @details
10898 *
10899 *    Function : freeAperDecodeSRBSetup
10900 *
10901 *    Functionality: added free part for the memory allocated by aper_decoder
10902 *
10903 * @params[in] SRBs_ToBeSetup_List_t *srbSet
10904 * @return void
10905 *
10906 ****************************************************************/
10907
10908
10909 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
10910 {
10911     uint8_t srbIdx =0;
10912     if(srbSet->list.array != NULLP)
10913     {
10914        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
10915        {
10916           if(srbSet->list.array[srbIdx]!=NULLP)
10917           {
10918              free(srbSet->list.array[srbIdx]);
10919           }
10920        }
10921        free(srbSet->list.array);
10922     }
10923 }
10924
10925 /*******************************************************************
10926 *
10927 * @brief free the memory allocated by decoder
10928 *
10929 * @details
10930 *
10931 *    Function : freeAperDecodeULTnlInfo
10932 *
10933 *    Functionality: added free part for the memory allocated by aper_decoder
10934 *
10935 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10936 * @return void
10937 *
10938 * ****************************************************************/
10939
10940
10941 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10942 {
10943    uint8_t ulIdx=0;
10944    if(ulInfo->list.array != NULLP)
10945    {
10946       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
10947       {
10948          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
10949          {
10950             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
10951             {
10952                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10953                      transportLayerAddress.buf != NULLP)
10954                {
10955                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10956                         !=NULLP)
10957                   {
10958                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
10959                   }
10960                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10961                         transportLayerAddress.buf);
10962                }
10963                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
10964             }
10965          }
10966          if(ulInfo->list.array[ulIdx]!=NULLP)
10967          {
10968             free(ulInfo->list.array[ulIdx]);
10969          }
10970       }
10971       free(ulInfo->list.array);
10972    }
10973 }
10974 /*******************************************************************
10975 *
10976 * @brief free the memory allocated by decoder
10977 *
10978 * @details
10979 *
10980 *    Function : freeAperDecodeDRBSetup
10981 *
10982 *    Functionality: free DRBSetup which is allocated by decoder
10983 *
10984 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
10985 * @return void
10986 *
10987 * ****************************************************************/
10988
10989 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
10990 {
10991    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
10992    uint8_t  flowIdx =0;
10993    uint8_t  drbIdx =0;
10994
10995    if(drbSet->list.array != NULLP)
10996    {
10997       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
10998       {
10999          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
11000          {
11001             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
11002             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
11003             {
11004                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11005                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
11006                {
11007                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11008                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11009                   {
11010                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11011                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11012                      {
11013
11014                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
11015                         {
11016
11017                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
11018                            {
11019
11020                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
11021                                     buf!=NULLP)
11022                               {
11023
11024                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
11025                                        flows_Mapped_To_DRB_List.list.array != NULLP)
11026                                  {
11027
11028                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11029                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
11030                                     {
11031
11032                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11033                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
11034                                        {
11035                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11036                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11037                                                 qoSFlowLevelQoSParameters.\
11038                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
11039                                           {
11040                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11041                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11042                                                    qoSFlowLevelQoSParameters.\
11043                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11044                                              {
11045
11046                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11047                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11048                                                       qoSFlowLevelQoSParameters.\
11049                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11050                                                 {
11051
11052
11053                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11054                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11055                                                          qoSFlowLevelQoSParameters.\
11056                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11057                                                 }
11058
11059                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11060                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11061                                                       qoSFlowLevelQoSParameters.\
11062                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11063                                              }
11064
11065                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11066
11067                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
11068                                                    qoSFlowLevelQoSParameters.\
11069                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
11070                                           }
11071                                        }
11072                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11073                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
11074                                        {
11075
11076                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11077                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
11078                                        }
11079                                     }
11080
11081                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11082                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
11083                                  }
11084
11085                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
11086                                        DRB_Information.sNSSAI.sD->buf);
11087                               }
11088
11089                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
11090                            }
11091
11092                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
11093
11094                         }
11095
11096                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11097
11098                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11099                      }
11100
11101                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11102                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11103                   }
11104
11105                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
11106                         qoS_Characteristics.choice.non_Dynamic_5QI);
11107                }
11108                free(drbSetItem->qoSInformation.choice.choice_extension);
11109             }
11110             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
11111             if(drbSetItem->uLConfiguration)
11112             {
11113                free(drbSetItem->uLConfiguration);
11114             }
11115          }
11116          if(drbSet->list.array[drbIdx]!=NULLP)
11117          {
11118             free(drbSet->list.array[drbIdx]);
11119          }
11120       }
11121       free(drbSet->list.array);
11122    }
11123 }
11124
11125
11126 /*******************************************************************
11127  *
11128  * @brief builds Mac Cell Cfg
11129  *
11130  * @details
11131  *
11132  *    Function : procUeReCfgCellInfo
11133  *
11134  *    Functionality: builds Mac Cell Cfg
11135  *
11136  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
11137  *                       needs to send in other layer, as well as this can be
11138  *                       the variable which stores the information in DuCb.
11139  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
11140  *                       information to other layer else it will have copyOfmacUeCfg
11141  *                       which we have stored in F1UeContextSetupDb
11142  *             void *cellInfo = CellGroupConfigRrc_t information which is send
11143  *                        by CU, which we have stored in F1UeContextSetupDb
11144  *
11145  * @return void
11146  *
11147  * ****************************************************************/
11148 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, MacUeCfg *storedMacUeCfg, void *cellInfo)
11149 {
11150    uint8_t ret = ROK;
11151    CellGroupConfigRrc_t *cellGrp = NULLP;
11152
11153    if(cellInfo)
11154    {
11155       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
11156       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
11157       if(ret == RFAILED)
11158          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
11159    }
11160    if(ret == RFAILED)
11161    {
11162       freeUeReCfgCellGrpInfo(macUeCfgToSend);
11163    }
11164    return ret;
11165 }
11166
11167 /*******************************************************************
11168  *
11169  * @brief Filling modulation info in mac ue cfg
11170  *
11171  * @details
11172  *
11173  *    Function : duFillModulationDetails
11174  *
11175  *    Functionality: Filling modulation info in mac ue cfg
11176  *
11177  * @params[in] MAC UE Config to be updated
11178  *             Current UE configuration
11179  *             UE NR capability from CU
11180  * @return ROK     - success
11181  *         RFAILED - failure
11182  *
11183  * ****************************************************************/
11184 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
11185 {
11186    UE_NR_Capability_t *ueNrCap=NULLP;
11187
11188    if(!ueCap && oldUeCfg)
11189    {
11190       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11191       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11192    }
11193    else
11194    {
11195       ueNrCap = (UE_NR_Capability_t *)ueCap;
11196
11197       /* Filling DL modulation info */
11198       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
11199          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
11200          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
11201       {
11202          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
11203          {
11204             case ModulationOrder_qpsk:
11205                {
11206                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
11207                   break;
11208                }
11209             case ModulationOrder_qam16:
11210                {
11211                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
11212                   break;
11213                }
11214             case ModulationOrder_qam64:
11215                {
11216                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
11217                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
11218                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
11219                   break;
11220                }
11221             case ModulationOrder_qam256:
11222                {
11223                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
11224                   break;
11225                }
11226             default:
11227                {
11228                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
11229                   if(oldUeCfg)
11230                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11231                   break;
11232                }
11233          }
11234       }
11235       else
11236       {
11237          if(oldUeCfg)
11238             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
11239       }
11240
11241       /* Filling UL modulation info */
11242       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
11243          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
11244          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
11245       {
11246          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
11247          {
11248             case ModulationOrder_qpsk:
11249                {
11250                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
11251                   break;
11252                }
11253             case ModulationOrder_qam16:
11254                {
11255                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
11256                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
11257                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
11258                   break;
11259                }
11260             case ModulationOrder_qam64:
11261                {
11262                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
11263                   break;
11264                }
11265             case ModulationOrder_qam256:
11266                {
11267                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
11268                   break;
11269                }
11270             default:
11271                {
11272                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
11273                   if(oldUeCfg)
11274                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11275                   break;
11276                }
11277          }
11278       }
11279       else
11280       {
11281          if(oldUeCfg)
11282             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
11283       }
11284    }
11285 }
11286
11287 /*******************************************************************
11288  *
11289  * @brief Function to extract info from CU to DU RRC container extension
11290  *
11291  * @details
11292  *
11293  *    Function : extractCuToDuRrcInfoExt
11294  *
11295  *    Functionality: Function to extract info from CU to DU RRC container
11296  *    extension
11297  *
11298  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
11299  *
11300  * @return ROK
11301  *         RFAILED
11302  *
11303  * ****************************************************************/
11304 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
11305 {
11306    uint8_t ieIdx =0;
11307    uint16_t recvBufLen =0;
11308    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
11309    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
11310    asn_dec_rval_t rval; /* Decoder return value */
11311    memset(&rval, 0, sizeof(asn_dec_rval_t));
11312
11313    if(protocolIeExtn)
11314    {
11315       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
11316       {
11317          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
11318          switch(extIeInfo->id)
11319          {
11320             case ProtocolIE_ID_id_CellGroupConfig:
11321                {
11322                   /* decoding the CellGroup Buf received */
11323                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
11324                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
11325                   if(cellGrpCfg)
11326                   {
11327                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
11328                      rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
11329                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
11330                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11331                      {
11332                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11333                         return RFAILED;
11334                      }
11335                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
11336
11337                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
11338                         return NULLP;
11339                      ueCfgDb->cellGrpCfg = cellGrpCfg;
11340                   }
11341                   break;
11342                }
11343
11344             case ProtocolIE_ID_id_HandoverPreparationInformation:
11345                {
11346                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
11347                   break;
11348                }
11349
11350             default:
11351                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
11352                break;
11353          }
11354       }
11355    }
11356    return ROK;
11357 }
11358
11359 /*******************************************************************
11360  *
11361  * @brief Fills Srb List received by CU
11362  *
11363  * @details
11364  *
11365  *    Function : procSrbListToSetup
11366  *
11367  *    Functionality: Fills Srb List received  by CU
11368  *
11369  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
11370  *             LcCfg pointer
11371  *             RlcBearerCfg pointer
11372  * @return void
11373  *
11374  * ****************************************************************/
11375 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
11376 {
11377
11378    /* Filling RLC INFO */
11379    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
11380
11381    /* Filling MAC INFO */
11382    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
11383    {
11384       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
11385       return RFAILED;
11386    }
11387
11388    return ROK;
11389 }
11390
11391
11392
11393 /*******************************************************************
11394  *
11395  * @brief extract Srb List received by CU
11396  *
11397  * @details
11398  *
11399  *    Function : extractSrbListToSetup
11400  *
11401  *    Functionality: extract Srb List received by CU
11402  *                   for both MAC and RLC
11403  *
11404  * @params[in] SRBs_ToBeSetup_Item_t pointer
11405  *             DuUeCfg pointer
11406  * @return ROK/RFAIED
11407  *
11408  * ****************************************************************/
11409
11410 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
11411 {
11412    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
11413    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
11414    LcCfg *macLcCtxt = NULLP;
11415    RlcBearerCfg *rlcLcCtxt = NULLP;
11416
11417    if(srbCfg)
11418    {
11419       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
11420       {
11421          macLcCtxt = NULL;
11422          rlcLcCtxt = NULL;
11423
11424          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
11425          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
11426          {
11427             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
11428             ret = RFAILED;
11429             break;
11430          }
11431          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
11432          {
11433             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
11434             ret = RFAILED;
11435             break;
11436          }
11437
11438          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
11439          {
11440             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_SRB)
11441             {
11442                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
11443                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
11444                break;
11445             }
11446          }
11447          if(!macLcCtxt)
11448          {
11449             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
11450             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
11451             ueCfgDb->numMacLcs++;
11452          }
11453          if(!rlcLcCtxt)
11454          {
11455             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
11456             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
11457             ueCfgDb->numRlcLcs++;
11458          }
11459
11460          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
11461
11462          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
11463                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
11464          if(ret == RFAILED)
11465          {
11466             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
11467             break;
11468          }
11469       }
11470    }
11471    else
11472       ret = RFAILED;
11473
11474    return ret;
11475 }
11476
11477 /*******************************************************************
11478  *
11479  * @brief Fills Drb List received by CU
11480  *
11481  * @details
11482  *
11483  *    Function : procDrbListToSetupMod
11484  *
11485  *    Functionality: Fills Drb List received by CU
11486  *                   for both MAC and RLC
11487  *
11488  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
11489  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
11490  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
11491  * @return void
11492  *
11493  * ****************************************************************/
11494
11495 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
11496 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
11497 {
11498    uint8_t cfgIdx = 0;
11499    RlcMode rlcModeInfo;
11500
11501    if(drbItem != NULLP)
11502    {
11503       /* Filling RLC INFO */
11504       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
11505       qoSInformation);
11506
11507       /* Filling MAC INFO */
11508       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
11509       {
11510          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11511          return RFAILED;
11512       }
11513    }
11514    else if(drbSetupModItem != NULLP)
11515    {
11516       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
11517       &drbSetupModItem->qoSInformation);
11518
11519       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
11520       {
11521          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11522          return RFAILED;
11523       }
11524    }
11525    else if(drbModItem != NULLP)
11526    {
11527       /* Drb to Mod IEs doesnot have rlcMode to be modified
11528        * in ASN. Hence no change in RLC configurations */
11529       if(storedRlcUeCfg != NULLP)
11530       {
11531          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
11532          {
11533             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
11534             {
11535                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
11536                break;
11537             }
11538          }
11539       }
11540
11541       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
11542       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
11543       {
11544          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
11545          return RFAILED;
11546       }
11547    }
11548    return ROK;
11549 }
11550
11551 /*******************************************************************
11552  *
11553  * @brief extract Drb List received by CU
11554  *
11555  * @details
11556  *
11557  *    Function : extractDrbListToSetupMod
11558  *
11559  *    Functionality: extract Drb List received by CU
11560  *                   for both MAC and RLC
11561  *
11562  * @params[in] DRBs_ToBeSetup_Item_t pointer
11563  *             DuUeCfg pointer
11564  * @return ROK/RFAIED
11565  *
11566  * ****************************************************************/
11567
11568 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
11569  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
11570 {
11571    uint8_t ret = ROK;
11572    uint8_t drbIdx = 0, rlcLcIdx = 0;
11573    uint8_t drbId = 0, lcId = 0;
11574    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
11575    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
11576    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
11577    LcCfg *macLcCtxt = NULLP;
11578    RlcBearerCfg *rlcLcCtxt = NULLP;
11579
11580    ret = ROK;
11581    if(drbCount > 0)
11582    {
11583       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
11584       {
11585          macLcCtxt = NULL;
11586          rlcLcCtxt = NULL;
11587
11588          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
11589          {
11590             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
11591             ret = RFAILED;
11592             break;
11593          }
11594          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
11595          {
11596             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
11597             ret = RFAILED;
11598             break;
11599          }
11600
11601          if(drbModCfg != NULLP)
11602          {
11603             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
11604             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
11605          }
11606          else if(drbCfg != NULLP)
11607             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
11608          else if(drbSetupModCfg != NULL)
11609          {
11610             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
11611             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
11612          }
11613
11614          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
11615          {
11616             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
11617             {
11618                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
11619                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
11620                break;
11621             }
11622          }
11623          if(!macLcCtxt)
11624          {
11625             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
11626             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
11627             ueCfgDb->numMacLcs++;
11628          }
11629          if(!rlcLcCtxt)
11630          {
11631             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
11632             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
11633             ueCfgDb->numRlcLcs++;
11634          }
11635
11636          if(drbModCfg != NULLP)
11637          {
11638             lcId = fetchLcId(drbId);
11639             if(lcId < MIN_DRB_LCID)
11640             {
11641                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
11642                break;
11643             }
11644             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
11645             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11646             if(ret == RFAILED)
11647             {
11648                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
11649                break;
11650             }
11651          }
11652          else
11653          {
11654             lcId = getDrbLcId(drbBitMap);
11655             if(lcId == RFAILED)
11656             {
11657                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
11658                ret = RFAILED;
11659                break;
11660             }
11661             if(drbCfg != NULL)
11662             {
11663                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
11664                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11665                if(ret == RFAILED)
11666                {
11667                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
11668                   break;
11669                }
11670             }
11671             else if(drbSetupModCfg != NULL)
11672             {
11673                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
11674                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
11675                if(ret == RFAILED)
11676                {
11677                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
11678                   break;
11679                }
11680                ueCfgDb->numDrbSetupMod++;
11681             }
11682          }
11683          ueCfgDb->numDrb++;
11684
11685          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
11686                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
11687          if(ret == RFAILED)
11688          {
11689             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
11690             break;
11691          }
11692       }
11693    }
11694    else
11695       ret = RFAILED;
11696
11697    return ret;
11698 }
11699
11700 /*******************************************************************
11701  *
11702  * @brief Function to extract Dl RRC Msg received from CU
11703  *
11704  * @details
11705  *
11706  *    Function : extractDlRrcMsg
11707  *
11708  *    Functionality: Function to extract Dl RRC Msg received from CU
11709  *
11710  * @params[in] F1AP message
11711  * @return ROK     - success
11712  *         RFAILED - failure
11713  *
11714  * ****************************************************************/
11715
11716 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
11717    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
11718 {
11719    uint8_t ret = ROK;
11720    dlRrcMsg->rrcMsgSize = rrcContainer->size;
11721    if(dlRrcMsg->rrcMsgSize > 0)
11722    {
11723       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
11724       if(!dlRrcMsg->rrcMsgPdu)
11725       {
11726          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
11727          ret = RFAILED;
11728       }
11729       else
11730       {
11731          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
11732          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
11733          dlRrcMsg->srbId = SRB1_LCID;
11734          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
11735       }
11736    }
11737    return ret;
11738 }
11739
11740 /*******************************************************************
11741  *
11742  * @brief Extract UE capability info
11743  *
11744  * @details
11745  *
11746  *    Function : extractUeCapability
11747  *
11748  *    Functionality: Extract UE capability info and stores in ue Cb
11749  *
11750  * @params[in] Octet string of UE capability RAT container list
11751  * @return ROK     - success
11752  *         RFAILED - failure
11753  *
11754  * ****************************************************************/
11755 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
11756 {
11757    uint8_t  idx;
11758    uint16_t recvBufLen;
11759    asn_dec_rval_t rval;
11760    UE_NR_Capability_t  *ueNrCap = NULLP;
11761    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
11762
11763    /* Decoding UE Capability RAT Container List */
11764    recvBufLen = ueCapablityListBuf->size;
11765    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11766    if(!ueCapRatContList)
11767    {
11768       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
11769       return NULLP;
11770    }
11771    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11772    memset(&rval, 0, sizeof(asn_dec_rval_t));
11773    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
11774           ueCapablityListBuf->buf, recvBufLen, 0, 0);
11775    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11776    {
11777       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11778       return NULLP;
11779    }
11780    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
11781
11782    /* Free encoded buffer after decoding */
11783
11784    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
11785    {
11786       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
11787       {
11788          /* Decoding UE NR Capability */
11789           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
11790           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
11791           if(!ueNrCap)
11792           {
11793              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
11794              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11795              return NULLP;
11796           }
11797           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
11798           memset(&rval, 0, sizeof(asn_dec_rval_t));
11799           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
11800                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
11801           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11802           {
11803              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
11804              return NULLP;
11805           }
11806           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
11807
11808           /* Free encoded buffer after decoding */
11809           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
11810       }
11811       free(ueCapRatContList->list.array[idx]);
11812    }
11813
11814    /* Free Memory*/
11815    free(ueCapRatContList->list.array);
11816    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
11817    return ueNrCap;
11818 }
11819
11820 /*******************************************************************
11821 *
11822 * @brief free UE context setup request from CU
11823 *
11824 * @details
11825 *
11826 *    Function : freeAperDecodeF1UeContextSetupReq
11827 *
11828 *    Functionality: freeing part for the memory allocated by aper_decoder
11829 *
11830 * @params[in] F1AP message
11831 * @return ROK     - success
11832 *         RFAILED - failure
11833 *
11834 * ****************************************************************/
11835 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
11836 {
11837    uint8_t ieIdx = 0;
11838
11839    if(ueSetReq->protocolIEs.list.array != NULLP)
11840    {
11841       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
11842       {
11843          if(ueSetReq->protocolIEs.list.array[ieIdx])
11844          {
11845             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
11846             {
11847                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11848                   break;
11849                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11850                   break;
11851                case ProtocolIE_ID_id_SpCell_ID:
11852                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
11853                   break;
11854                case ProtocolIE_ID_id_ServCellIndex:
11855                   break;
11856                case ProtocolIE_ID_id_SpCellULConfigured:
11857                   break;
11858                case ProtocolIE_ID_id_CUtoDURRCInformation:
11859
11860                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
11861                   break;
11862                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
11863
11864                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
11865                   break;
11866                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
11867
11868                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
11869                   break;
11870                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
11871
11872                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
11873                   break;
11874                case ProtocolIE_ID_id_RRCContainer:
11875                   {
11876
11877                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
11878                      {
11879
11880                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
11881                      }
11882                      break;
11883                   }
11884                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11885                   break;
11886                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
11887                   {
11888                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
11889                      {
11890                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
11891                      }
11892                      break;
11893                   }
11894                default:
11895                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
11896             }
11897             free(ueSetReq->protocolIEs.list.array[ieIdx]);
11898          }
11899       }
11900       free(ueSetReq->protocolIEs.list.array);
11901    }
11902 }
11903 /*******************************************************************
11904  *
11905  * @brief Process UE context setup request from CU
11906  *
11907  * @details
11908  *
11909  *    Function : procF1UeContextSetupReq
11910  *
11911  *    Functionality: Process UE context setup request from CU
11912  *
11913  * @params[in] F1AP message
11914  * @return ROK     - success
11915  *         RFAILED - failure
11916  *
11917  * ****************************************************************/
11918 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
11919 {
11920    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0, ueIdx=0, cellIdx=0, servCellIdx = 0;
11921    bool ueCbFound = false, hoInProgress = false;
11922    uint16_t nrCellId = 0;
11923    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
11924    DuUeCb   *duUeCb = NULL;
11925    UEContextSetupRequest_t   *ueSetReq = NULL;
11926    DRBs_ToBeSetup_List_t *drbCfg = NULL;
11927    CUtoDURRCInformation_t *rrcInfo = NULL;
11928
11929    ret = ROK;
11930
11931    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
11932    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
11933    {
11934       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
11935       {
11936          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11937             {
11938                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11939                break;
11940             }
11941
11942          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11943             {
11944                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11945                break;
11946             }
11947
11948          case ProtocolIE_ID_id_SpCell_ID:
11949             {
11950                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
11951
11952                GET_CELL_IDX(nrCellId, cellIdx);
11953                if(!duCb.actvCellLst[cellIdx])
11954                {
11955                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%d] not found", nrCellId);
11956                   ret = RFAILED;
11957                }
11958                break;
11959             }
11960
11961          case ProtocolIE_ID_id_ServCellIndex:
11962             {
11963                servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
11964                break;
11965             }
11966
11967          case ProtocolIE_ID_id_SpCellULConfigured:
11968             {
11969                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
11970                   UL, SUL or UL+SUL for the indicated cell for the UE */
11971                break;
11972             }
11973
11974          case ProtocolIE_ID_id_CUtoDURRCInformation:
11975             {
11976                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
11977
11978                /* Search if UE context is present */
11979                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11980                {
11981                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
11982                   {
11983                      ueCbFound = true;
11984                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
11985                      break;
11986                   }
11987                }
11988
11989                /* Check if UE Handover scenario */
11990                if(rrcInfo->iE_Extensions)
11991                {
11992                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
11993                   {
11994                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
11995                      {
11996                         hoInProgress = true;
11997                         break;
11998                      }
11999                   }
12000                }
12001
12002                /* If UE context is not present, but UE is in handover */
12003                if(!ueCbFound && hoInProgress)
12004                {
12005                   gnbDuUeF1apId = genGnbDuUeF1apId(nrCellId);
12006                   duUeCb = &duCb.actvCellLst[cellIdx]->hoUeCb[gnbDuUeF1apId -1];
12007                   duUeCb->f1UeDb = NULL;
12008                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
12009                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
12010                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
12011                }
12012
12013                if(duUeCb)
12014                {
12015                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12016                   if(duUeCb->f1UeDb)
12017                   {
12018                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
12019                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
12020                      duUeCb->f1UeDb->cellIdx = cellIdx;
12021                   }
12022                   else
12023                   {
12024                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
12025                      ret = RFAILED;
12026                      break;
12027                   }
12028                }
12029                else
12030                {
12031                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
12032                   ret = RFAILED;
12033                   break;
12034                }
12035
12036                /* Extract UE capability info */
12037                if(rrcInfo->uE_CapabilityRAT_ContainerList)
12038                {
12039                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
12040                }
12041
12042                /* Extract IE extension */
12043                if(rrcInfo->iE_Extensions)
12044                {
12045                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
12046                   {
12047                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
12048                      //TODO: Update the failure cause in ue context Setup Response
12049                      ret = RFAILED;
12050                   }
12051                }
12052                break;
12053             }
12054
12055          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
12056             {
12057                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
12058                break;
12059             }
12060
12061          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
12062             {
12063                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
12064                         &duUeCb->f1UeDb->duUeCfg))
12065                {
12066                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
12067                   //TODO: Update the failure cause in ue context Setup Response
12068                   ret = RFAILED;
12069                }
12070                break;
12071             }
12072
12073          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
12074             {
12075                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
12076
12077                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
12078                {
12079                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
12080                   //TODO: Update the failure cause in ue context Setup Response
12081                   ret = RFAILED;
12082                }
12083                break;
12084             }
12085
12086          case ProtocolIE_ID_id_RRCContainer:
12087             {
12088                /* Filling Dl RRC Msg Info */
12089                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
12090                if(!duUeCb->f1UeDb->dlRrcMsg)
12091                {
12092                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
12093                   ret = RFAILED;
12094                }
12095                else
12096                {
12097                   duUeCb->f1UeDb->dlRrcMsgPres = true;
12098                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
12099                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
12100                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
12101                }
12102                break;
12103             }
12104
12105          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12106             {
12107                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
12108                {
12109                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
12110                }
12111                else
12112                {
12113                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
12114                }
12115                break;
12116             }
12117
12118          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
12119             {
12120                /* MaximumBitRate Uplink */
12121                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
12122                if(bitRateSize > 0)
12123                {
12124                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
12125                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
12126                   {
12127                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
12128                      ret = RFAILED;
12129                   }
12130                   else
12131                   {
12132                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
12133                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
12134                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
12135                   }
12136                }
12137                else
12138                   ret = RFAILED;
12139                break;
12140             }
12141
12142          default:
12143             {
12144                break;
12145             }
12146       } /* End of switch */
12147
12148       /* In case of any failure in any IE */
12149       if(ret == RFAILED)
12150       {
12151          // BuildAndSendUeContextSetupRsp(cellId,ueId);
12152          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
12153          break;
12154       }
12155    } /* End of for loop of IEs */
12156
12157    if(ret == ROK)
12158       ret = duProcUeContextSetupRequest(duUeCb);
12159
12160    freeAperDecodeF1UeContextSetupReq(ueSetReq);
12161    return ret;
12162
12163 }
12164 /*******************************************************************
12165  * @brief Free the memory allocated for Dl Tunnel Info
12166  *
12167  * @details
12168  *
12169  *    Function : freeDlTnlInfo
12170  *
12171  *    Functionality:
12172  *       Free the memory allocated for Dl Tunnel Info
12173  *
12174  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
12175  * @return void
12176  *
12177  * ****************************************************************/
12178
12179 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
12180 {
12181    uint8_t arrIdx = 0;
12182
12183    if(tnlInfo)
12184    {
12185       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
12186       {
12187          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
12188                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
12189          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
12190                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
12191          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
12192          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
12193       }
12194       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
12195    }
12196 }
12197
12198 /*******************************************************************
12199  * @brief Free the memory allocated for DRB setup List
12200  *
12201  * @details
12202  *
12203  *    Function : freeDrbSetupList
12204  *
12205  *    Functionality:
12206  *       Free the memory allocated for DRB setup list
12207  *
12208  * @params[in] DRBs_Setup_List_t *
12209  * @return void
12210  *
12211  * ****************************************************************/
12212 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
12213 {
12214    uint8_t arrIdx = 0;
12215    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
12216
12217    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12218    {
12219       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12220       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
12221       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
12222    }
12223    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12224 }
12225
12226 /*******************************************************************
12227  * @brief Free the memory allocated for UE Setup response
12228  *
12229  * @details
12230  *
12231  *    Function : FreeUeContextSetupRsp
12232  *
12233  *    Functionality:
12234  *       Free the memory allocated for UE Setup response
12235  *
12236  * @params[in] F1AP PDU for UE setup response
12237  * @return ROK     - success
12238  *         RFAILED - failure
12239  *
12240  * ****************************************************************/
12241 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
12242 {
12243    uint8_t idx;
12244    UEContextSetupResponse_t *ueSetRsp = NULLP;
12245
12246    if(f1apMsg)
12247    {
12248       if(f1apMsg->choice.successfulOutcome)
12249       {
12250          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
12251                     UEContextSetupResponse;
12252          if(ueSetRsp->protocolIEs.list.array)
12253          {
12254             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
12255             {
12256                if(ueSetRsp->protocolIEs.list.array[idx])
12257                {
12258                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
12259                   {
12260                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12261                         break;
12262                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12263                         break;
12264                      case ProtocolIE_ID_id_DUtoCURRCInformation:
12265                         {
12266                            CellGroupConfig_t *cellGrpCfg = NULLP;
12267                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
12268                                          DUtoCURRCInformation.cellGroupConfig;
12269                            if(cellGrpCfg->buf != NULLP)
12270                            {
12271                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
12272                               cellGrpCfg = NULLP;
12273                            }
12274                            break;
12275                         }
12276                     case ProtocolIE_ID_id_DRBs_Setup_List:
12277                         {
12278                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
12279                            break;
12280                         }
12281                      default:
12282                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
12283                         ueSetRsp->protocolIEs.list.array[idx]->id);
12284                         break;
12285                   }
12286                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
12287                         sizeof(UEContextSetupResponseIEs_t));
12288                }
12289             }
12290             DU_FREE(ueSetRsp->protocolIEs.list.array, \
12291                   ueSetRsp->protocolIEs.list.size);
12292          }
12293          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12294       }
12295       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12296    }
12297 }
12298
12299 /*******************************************************************
12300  *
12301  * @brief Builds Ue context Setup Rsp DU To CU Info
12302  *
12303  * @details
12304  *
12305  *    Function : EncodeUeCntxtDuToCuInfo
12306  *
12307  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
12308  *
12309  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
12310  *
12311  * @return ROK     - success
12312  *         RFAILED - failure
12313  *
12314  ******************************************************************/
12315
12316 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
12317 {
12318    asn_enc_rval_t        encRetVal;
12319
12320    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
12321    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
12322    encBufSize = 0;
12323    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
12324    /* Encode results */
12325    if(encRetVal.encoded == ENCODE_FAIL)
12326    {
12327       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
12328             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12329       return RFAILED;
12330    }
12331    else
12332    {
12333       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
12334       for(int i=0; i< encBufSize; i++)
12335       {
12336          printf("%x",encBuf[i]);
12337       }
12338    }
12339    duToCuCellGrp->size = encBufSize;
12340    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
12341    if(!duToCuCellGrp->buf)
12342    {
12343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
12344    }
12345    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
12346    return ROK;
12347 }
12348
12349 /*******************************************************************
12350  *
12351  * @brief Fills Dl Gtp tunnel Info
12352  *
12353  * @details
12354  *
12355  *    Function : fillGtpTunnelforDl
12356  *
12357  *    Functionality: Fills Dl Gtp tunnel Info
12358  *
12359  * @params[in]
12360  *
12361  * @return ROK     - success
12362  *         RFAILED - failure
12363  *
12364  * ****************************************************************/
12365
12366 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
12367 {
12368    uint8_t bufSize = 0;
12369
12370    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
12371    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
12372    if(gtpDl->transportLayerAddress.buf == NULLP)
12373    {
12374       return RFAILED;
12375    }
12376    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
12377
12378    /*GTP TEID*/
12379    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
12380    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
12381    if(gtpDl->gTP_TEID.buf == NULLP)
12382    {
12383       return RFAILED;
12384    }
12385    bufSize = 3; /*forming an Octect String*/
12386    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
12387
12388    return ROK;
12389 }
12390
12391 /*******************************************************************
12392  *
12393  * @brief Fills DL Tunnel Setup List
12394  *
12395  * @details
12396  *
12397  *    Function : fillDlTnlSetupList
12398  *
12399  *    Functionality: Fills the DL Tunnel Setup List
12400  *
12401  * @params[in]
12402  *
12403  * @return ROK     - success
12404  *         RFAILED - failure
12405  *
12406  * ****************************************************************/
12407
12408 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
12409 {
12410    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
12411
12412    eleCount = 1;
12413    dlTnlInfo->list.count = eleCount;
12414    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
12415
12416    /* Initialize the DL Tnl Setup List Members */
12417    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
12418    if(dlTnlInfo->list.array == NULLP)
12419    {
12420       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
12421       ret = RFAILED;
12422    }
12423    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
12424    {
12425       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
12426       if(dlTnlInfo->list.array[arrIdx] == NULLP)
12427       {
12428          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
12429          return RFAILED;
12430       }
12431       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
12432       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
12433       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
12434       {
12435          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
12436          return RFAILED;
12437       }
12438       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
12439                tnlCfg->tnlCfg1);
12440       if(ret != ROK)
12441          break;
12442    }
12443    return ret;
12444 }
12445
12446 /*******************************************************************
12447  *
12448  * @brief Fills the Drb Setup List for Ue Context Setup Response
12449  *
12450  * @details
12451  *
12452  *    Function : fillDrbSetupList
12453  *
12454  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
12455  *
12456  * @params[in]
12457  *
12458  * @return ROK     - success
12459  *         RFAILED - failure
12460  *
12461  * ****************************************************************/
12462 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
12463 {
12464    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
12465    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
12466
12467    eleCount = ueCfg->numDrb;
12468    drbSetupList->list.count = eleCount;
12469    drbSetupList->list.size = \
12470         (eleCount * sizeof(DRBs_Setup_Item_t *));
12471
12472    /* Initialize the Drb Setup List Members */
12473    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
12474    if(drbSetupList->list.array == NULLP)
12475    {
12476       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
12477       ret = RFAILED;
12478    }
12479
12480    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
12481    {
12482       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
12483       if(drbSetupList->list.array[arrIdx] == NULLP)
12484       {
12485          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
12486          return RFAILED;
12487       }
12488       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12489       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
12490       drbItemIe->criticality = Criticality_reject;
12491       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
12492       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12493       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
12494           &ueCfg->upTnlInfo[arrIdx]);
12495       if(ret != ROK)
12496          break;
12497    }
12498    return ret;
12499 }
12500
12501 /*******************************************************************
12502  *
12503  * @brief Builds and sends the UE Setup Response
12504  *
12505  * @details
12506  *
12507  *    Function : BuildAndSendUeContextSetupRsp
12508  *
12509  *    Functionality: Constructs the UE Setup Response and sends
12510  *                   it to the DU through SCTP.
12511  *
12512  * @params[in] uint8_t cellId,uint8_t ueId
12513  *
12514  * @return ROK     - success
12515  *         RFAILED - failure
12516  *
12517  * ****************************************************************/
12518 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
12519 {
12520    uint8_t   idx, ret, cellIdx, elementCnt;
12521    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12522    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12523    asn_enc_rval_t  encRetVal;        /* Encoder return value */
12524    F1AP_PDU_t               *f1apMsg = NULLP;
12525    UEContextSetupResponse_t *ueSetRsp = NULLP;
12526    DuUeCb                   *ueCb = NULLP;
12527
12528    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
12529
12530    while(true)
12531    {
12532       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12533       if(f1apMsg == NULLP)
12534       {
12535          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12536          ret = RFAILED;
12537          break;
12538       }
12539
12540       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
12541       DU_ALLOC(f1apMsg->choice.successfulOutcome,
12542             sizeof(SuccessfulOutcome_t));
12543       if(f1apMsg->choice.successfulOutcome == NULLP)
12544       {
12545          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
12546          ret = RFAILED;
12547          break;
12548       }
12549
12550       f1apMsg->choice.successfulOutcome->procedureCode = \
12551                                                          ProcedureCode_id_UEContextSetup;
12552       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12553       f1apMsg->choice.successfulOutcome->value.present = \
12554                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
12555
12556       ueSetRsp =
12557          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
12558       elementCnt = 4;
12559       ueSetRsp->protocolIEs.list.count = elementCnt;
12560       ueSetRsp->protocolIEs.list.size = \
12561                                         elementCnt * sizeof(UEContextSetupResponse_t *);
12562
12563       /* Initialize the UESetup members */
12564       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
12565             ueSetRsp->protocolIEs.list.size);
12566       if(ueSetRsp->protocolIEs.list.array == NULLP)
12567       {
12568          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
12569          ret = RFAILED;
12570          break;
12571       }
12572
12573       for(idx=0; idx<elementCnt; idx++)
12574       {
12575          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
12576                sizeof(UEContextSetupResponseIEs_t));
12577          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
12578          {
12579             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
12580             ret = RFAILED;
12581             break;
12582          }
12583       }
12584       /* Fetching Ue Cb Info*/
12585       GET_CELL_IDX(cellId, cellIdx);
12586       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
12587       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
12588       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
12589
12590       idx = 0;
12591       /*GNB CU UE F1AP ID*/
12592       ueSetRsp->protocolIEs.list.array[idx]->id = \
12593                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12594       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12595       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
12596                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12597       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12598
12599       /*GNB DU UE F1AP ID*/
12600       idx++;
12601       ueSetRsp->protocolIEs.list.array[idx]->id = \
12602                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12603       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12604       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
12605                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12606       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12607
12608
12609       /*DUtoCURRC Information */
12610       idx++;
12611       ueSetRsp->protocolIEs.list.array[idx]->id  = \
12612                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
12613       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12614       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
12615                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
12616       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
12617
12618       /* Drb Setup List */
12619       idx++;
12620       ueSetRsp->protocolIEs.list.array[idx]->id  = \
12621                                                    ProtocolIE_ID_id_DRBs_Setup_List;
12622       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12623       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
12624                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
12625       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
12626             &ueCb->f1UeDb->duUeCfg);
12627       if(ret == RFAILED)
12628       {
12629          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
12630          freeF1UeDb(ueCb->f1UeDb);
12631          ueCb->f1UeDb = NULLP;
12632          break;
12633       }
12634
12635       /* Free UeContext Db created during Ue context Req */
12636       freeF1UeDb(ueCb->f1UeDb);
12637       ueCb->f1UeDb = NULLP;
12638
12639       /* TODO: To send Drb list */
12640       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12641
12642       /* Encode the UE context setup response type as APER */
12643       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
12644       encBufSize = 0;
12645       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12646             encBuf);
12647       /* Encode results */
12648       if(encRetVal.encoded == ENCODE_FAIL)
12649       {
12650          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
12651                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12652          ret = RFAILED;
12653          break;
12654       }
12655       else
12656       {
12657          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
12658          for(int i=0; i< encBufSize; i++)
12659          {
12660             printf("%x",encBuf[i]);
12661          }
12662       }
12663
12664       /* Sending  msg  */
12665       if(sendF1APMsg()  != ROK)
12666       {
12667          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
12668          ret = RFAILED;
12669          break;
12670       }
12671       break;
12672    }
12673    FreeUeContextSetupRsp(f1apMsg);
12674    return ret;
12675 }/* End of BuildAndSendUeContextSetupRsp */
12676 /*******************************************************************
12677 *
12678 * @brief  Build And Send Ue Context Rsp
12679 *
12680 * @details
12681 *
12682 *    Function : BuildAndSendUeCtxtRsp
12683 *
12684 *    Functionality : Build And Send Ue Context Rsp
12685
12686 * @params[in]
12687 * @return sucess = ROK
12688 *         failure = RFAILED
12689 *
12690 * ****************************************************************/
12691 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
12692 {
12693    uint8_t cellIdx = 0, actionType = 0;
12694
12695    GET_CELL_IDX(cellId, cellIdx);
12696    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
12697
12698    switch(actionType)
12699    {
12700       case UE_CTXT_SETUP:
12701          {
12702             BuildAndSendUeContextSetupRsp(cellId,ueId);
12703             break;
12704          }
12705       case UE_CTXT_MOD:
12706          {
12707             BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1]);
12708             break;
12709          }
12710       default:
12711          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
12712          break;
12713
12714    }
12715    return ROK;
12716 }
12717
12718 /*******************************************************************
12719  *
12720  * @brief deallocating the memory of  F1reset msg
12721  *
12722  * @details
12723  *
12724  *    Function : FreeF1ResetReq
12725  *
12726  *    Functionality :
12727  *         - freeing memory of F1reset request msg
12728  *
12729  * @params[in]
12730  * @return void
12731  *
12732  *
12733  * ****************************************************************/
12734 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
12735 {
12736    uint8_t idx =0 ;
12737    Reset_t *f1ResetMsg;
12738
12739    if(f1apMsg)
12740    {
12741       if(f1apMsg->choice.initiatingMessage)
12742       {
12743          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12744
12745          if(f1ResetMsg->protocolIEs.list.array)
12746          {
12747             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
12748             {
12749                if(f1ResetMsg->protocolIEs.list.array[idx])
12750                {
12751                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
12752                }
12753             }
12754             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
12755          }
12756          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12757       }
12758       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12759    }
12760 }
12761 /*******************************************************************
12762  *
12763  * @brief Build and Send F1reset request
12764  *
12765  * @details
12766  *
12767  *    Function : BuildAndSendF1ResetReq
12768  *
12769  *    Functionality:
12770  *         - Build and Send F1reset request msg
12771  *
12772  * @params[in]
12773  * @return ROK     - success
12774  *         RFAILED - failure
12775  *
12776  * ****************************************************************/
12777 uint8_t BuildAndSendF1ResetReq()
12778 {
12779    uint8_t          elementCnt=0;
12780    uint8_t          idx=0;
12781    uint8_t          ret= RFAILED;
12782    Reset_t          *f1ResetMsg = NULLP;
12783    F1AP_PDU_t       *f1apMsg = NULLP;
12784    asn_enc_rval_t   encRetVal;
12785    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
12786    do
12787    {
12788       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12789       if(f1apMsg == NULLP)
12790       {
12791          break;
12792       }
12793       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12794       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12795       if(f1apMsg->choice.initiatingMessage == NULLP)
12796       {
12797          break;
12798       }
12799       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
12800       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12801       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
12802
12803       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12804
12805       elementCnt = 3;
12806       f1ResetMsg->protocolIEs.list.count = elementCnt;
12807       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
12808
12809       /* Initialize the F1Setup members */
12810       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
12811       if(f1ResetMsg->protocolIEs.list.array == NULLP)
12812       {
12813          break;
12814       }
12815       for(idx=0; idx<elementCnt; idx++)
12816       {
12817          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
12818          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
12819          {
12820             break;
12821          }
12822       }
12823
12824       /*TransactionID*/
12825       idx=0;
12826       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
12827       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12828       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
12829       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
12830
12831       /*Cause*/
12832       idx++;
12833       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
12834       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
12835       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
12836       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
12837       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
12838
12839       /*Reset Type*/
12840       idx++;
12841       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
12842       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12843       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
12844       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
12845       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
12846
12847       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12848
12849       /* Encode the F1SetupRequest type as APER */
12850       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12851       encBufSize = 0;
12852       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12853             encBuf);
12854
12855       /* Encode results */
12856       if(encRetVal.encoded == ENCODE_FAIL)
12857       {
12858          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
12859                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12860          break;
12861       }
12862       else
12863       {
12864          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
12865          for(idx=0; idx< encBufSize; idx++)
12866          {
12867             printf("%x",encBuf[idx]);
12868          }
12869       }
12870
12871       if(sendF1APMsg() != ROK)
12872       {
12873          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
12874          break;
12875       }
12876
12877       ret = ROK;
12878       break;
12879    }while(true);
12880
12881    FreeF1ResetReq(f1apMsg);
12882    return ret;
12883 }
12884 /*******************************************************************
12885  *
12886  * @brief Build And Send F1ResetAck
12887  *
12888  * @details
12889  *
12890  *    Function : BuildAndSendF1ResetAck
12891  *
12892  *    Functionality:
12893  *         - Build And Send  F1ResetRSP
12894  *
12895  * @return ROK     - success
12896  *         RFAILED - failure
12897  *
12898  * ****************************************************************/
12899 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
12900 {
12901    uint8_t idx;
12902    ResetAcknowledge_t *f1ResetAck;
12903
12904    if(f1apMsg)
12905    {
12906       if(f1apMsg->choice.successfulOutcome)
12907       {
12908          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
12909
12910          if(f1ResetAck->protocolIEs.list.array)
12911          {
12912             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
12913             {
12914                if(f1ResetAck->protocolIEs.list.array[idx])
12915                {
12916                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
12917                }
12918             }
12919             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
12920          }
12921          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12922       }
12923       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12924    }
12925 }
12926
12927 /*******************************************************************
12928  *
12929  * @brief Build And Send F1ResetAck
12930  *
12931  * @details
12932  *
12933  *    Function : BuildAndSendF1ResetAck
12934  *
12935  *    Functionality:
12936  *         - Build And Send  F1ResetRSP
12937  *
12938  *  @params[in]
12939  * @return ROK     - success
12940  *         RFAILED - failure
12941  *
12942  * ****************************************************************/
12943 uint8_t BuildAndSendF1ResetAck()
12944 {
12945    uint8_t                idx = 0;
12946    uint8_t                elementCnt = 0;
12947    uint8_t                ret = RFAILED;
12948    F1AP_PDU_t             *f1apMsg = NULL;
12949    ResetAcknowledge_t     *f1ResetAck = NULLP;
12950    asn_enc_rval_t         encRetVal;
12951    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
12952
12953    do{
12954       /* Allocate the memory for F1ResetRequest_t */
12955       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12956       if(f1apMsg == NULLP)
12957       {
12958          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12959          break;
12960       }
12961
12962       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12963
12964       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12965       if(f1apMsg->choice.successfulOutcome == NULLP)
12966       {
12967          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12968          break;
12969       }
12970       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
12971       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
12972       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
12973
12974       elementCnt = 1;
12975
12976       f1ResetAck->protocolIEs.list.count = elementCnt;
12977       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
12978
12979       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
12980       if(f1ResetAck->protocolIEs.list.array == NULLP)
12981       {
12982          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
12983          break;
12984       }
12985
12986       for(idx=0; idx<elementCnt; idx++)
12987       {
12988          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
12989          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
12990          {
12991             break;
12992          }
12993       }
12994       /*TransactionID*/
12995       idx = 0;
12996       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
12997       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12998       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
12999       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
13000
13001       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13002
13003       /* Encode the F1SetupRequest type as UPER */
13004       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13005       encBufSize = 0;
13006       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13007
13008       /* Check encode results */
13009       if(encRetVal.encoded == ENCODE_FAIL)
13010       {
13011          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
13012                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13013          break;
13014       }
13015       else
13016       {
13017          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
13018          for(int i=0; i< encBufSize; i++)
13019          {
13020             printf("%x",encBuf[i]);
13021          }
13022       }
13023       /* Sending msg */
13024       if(sendF1APMsg() != ROK)
13025       {
13026          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
13027          break;
13028       }
13029
13030       ret = ROK;
13031       break;
13032    }while(true);
13033
13034    FreeF1ResetAck(f1apMsg);
13035    return ret;
13036 }
13037 /******************************************************************
13038 *
13039 * @brief free F1 reset msg allocated by aper_decoder
13040 *
13041 * @details
13042 *
13043 *    Function : freeAperDecodeF1ResetMsg
13044 *
13045 *    Functionality: free F1 reset msg allocated by aper_decoder
13046 *
13047 * @params[in] Reset_t *f1ResetMsg
13048 * @return void
13049 *
13050 * ****************************************************************/
13051
13052 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
13053 {
13054    uint8_t ieIdx =0;
13055    if(f1ResetMsg->protocolIEs.list.array)
13056    {
13057       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
13058       {
13059          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
13060          {
13061             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
13062          }
13063       }
13064       free(f1ResetMsg->protocolIEs.list.array);
13065    }
13066 }
13067
13068 /******************************************************************
13069  *
13070  * @brief Processes DL RRC Message Transfer  sent by CU
13071  *
13072  * @details
13073  *
13074  *    Function : procF1ResetReq
13075  *
13076  *    Functionality: Processes DL RRC Message Transfer sent by CU
13077  *
13078  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13079  * @return ROK     - success
13080  *         RFAILED - failure
13081  *
13082  * ****************************************************************/
13083 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
13084 {
13085    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
13086    uint8_t       ieIdx = 0;
13087    uint8_t        ret = ROK;
13088    Reset_t       *f1ResetMsg = NULLP;
13089
13090    DU_LOG("\nINFO   -->  Processing F1 reset request");
13091    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
13092
13093    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
13094    {
13095       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
13096       {
13097          case ProtocolIE_ID_id_TransactionID:
13098             break;
13099
13100          case ProtocolIE_ID_id_Cause:
13101             break;
13102
13103          case ProtocolIE_ID_id_ResetType:
13104             {
13105                break;
13106             }
13107
13108          default:
13109             break;
13110       }
13111    }
13112    ret = BuildAndSendF1ResetAck();
13113    DU_LOG("\nINFO   -->  UE release is not supported for now");
13114
13115    freeAperDecodeF1ResetMsg(f1ResetMsg);
13116
13117    return ret;
13118 }
13119
13120 /*******************************************************************
13121  *
13122  * @brief free the RRC delivery report
13123  *
13124  * @details
13125  *
13126  *    Function : freeRrcDeliveryReport
13127  *
13128  *    Functionality: free the RRC delivery report
13129  *
13130  * @params[in]
13131  * @return ROK     - success
13132  *         RFAILED - failure
13133  *
13134  * ****************************************************************/
13135 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
13136 {
13137    uint8_t idx=0;
13138    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
13139
13140    if(f1apMsg)
13141    {
13142       if(f1apMsg->choice.initiatingMessage)
13143       {
13144          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
13145          if(rrcDeliveryReport->protocolIEs.list.array)
13146          {
13147             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
13148                   idx++)
13149             {
13150                if(rrcDeliveryReport->protocolIEs.list.array[idx])
13151                {
13152                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
13153                         sizeof(RRCDeliveryReportIEs_t));
13154                }
13155             }
13156             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
13157                   rrcDeliveryReport->protocolIEs.list.size);
13158          }
13159          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
13160       }
13161       DU_FREE(f1apMsg,
13162             sizeof(F1AP_PDU_t));
13163    }
13164 }
13165
13166 /*******************************************************************
13167 *
13168 * @brief Builds and sends the RRC delivery report
13169 *
13170 * @details
13171 *
13172 *    Function : BuildAndSendRrcDeliveryReport
13173 *
13174 *    Functionality: Builds and sends the RRC delivery report
13175 *
13176 * @params[in]
13177 *
13178 * @return ROK     - success
13179 *         RFAILED - failure
13180 *
13181 * ****************************************************************/
13182 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
13183    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
13184 {
13185    uint8_t             ret = RFAILED;
13186    uint8_t             idx    = 0;
13187    uint8_t             idx1   = 0;
13188    uint8_t             elementCnt = 0;
13189    F1AP_PDU_t          *f1apMsg = NULLP;
13190    asn_enc_rval_t      encRetVal;
13191    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
13192
13193    do{
13194
13195       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
13196       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13197       if(f1apMsg == NULLP)
13198       {
13199          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
13200          break;
13201       }
13202       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13203       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
13204       if(f1apMsg->choice.initiatingMessage == NULLP)
13205       {
13206          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
13207          break;
13208       }
13209       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
13210       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
13211       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
13212
13213       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
13214       elementCnt = 4;
13215       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
13216       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
13217
13218       /* Initialize the F1Setup members */
13219       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
13220       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
13221       {
13222          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
13223          break;
13224       }
13225       for(idx =0 ;idx <elementCnt; idx++)
13226       {
13227          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
13228          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
13229          {
13230             break;
13231          }
13232       }
13233
13234       idx1 = 0;
13235
13236       /*GNB CU UE F1AP ID*/
13237       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13238       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
13239       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
13240       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
13241
13242       /*GNB DU UE F1AP ID*/
13243       idx1++;
13244       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13245       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
13246       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
13247       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
13248
13249       /*RRC delivery status*/
13250       idx1++;
13251       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
13252       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
13253       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
13254       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
13255       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
13256       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
13257       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
13258
13259       /* SRB ID */
13260       idx1++;
13261       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
13262       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
13263       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
13264       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
13265
13266       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13267
13268       /* Encode the RRC DELIVERY REPORT type as APER */
13269       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13270       encBufSize = 0;
13271       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
13272             encBuf);
13273
13274       /* Encode results */
13275       if(encRetVal.encoded == ENCODE_FAIL)
13276       {
13277          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
13278                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13279          break;
13280       }
13281       else
13282       {
13283          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
13284          for(idx=0; idx< encBufSize; idx++)
13285          {
13286             printf("%x",encBuf[idx]);
13287          }
13288       }
13289
13290       /* Sending msg */
13291       if(sendF1APMsg() != ROK)
13292       {
13293          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
13294          break;
13295       }
13296       ret = ROK;
13297       break;
13298
13299    }while(true);
13300
13301    freeRrcDeliveryReport(f1apMsg);
13302    return ret;
13303 }
13304
13305 /*******************************************************************
13306  *
13307  * @brief Processes cells to be activated
13308  *
13309  * @details
13310  *
13311  *    Function : extractCellsToBeActivated
13312  *
13313  *    Functionality:
13314  *      - Processes cells to be activated list received in F1SetupRsp
13315  *
13316  * @params[in] void
13317  * @return ROK     - success
13318  *         RFAILED - failure
13319  *
13320  * ****************************************************************/
13321
13322 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
13323 {
13324    uint8_t  ret = ROK;
13325    uint16_t idx, nci, pci = 0;
13326    Cells_to_be_Activated_List_Item_t cell;
13327
13328    for(idx=0; idx<cellsToActivate.list.count; idx++)
13329    {
13330       nci = 0;
13331       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
13332       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
13333
13334       if(cell.nRPCI)
13335       {
13336          pci = *cell.nRPCI;
13337       }
13338       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
13339    }
13340    return ret;
13341 }
13342 /******************************************************************
13343 *
13344 * @brief Processes F1 Setup Response allocated by aper_decoder
13345 *
13346 * @details
13347 *
13348 *    Function : freeF1SetupRsp
13349 *
13350 *    Functionality: free F1 Setup Response allocated by aper_decoder
13351 *
13352 * @params[in] F1SetupResponse_t *f1SetRspMsg
13353 * @return void
13354 *
13355 * ****************************************************************/
13356
13357 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
13358 {
13359    uint8_t ieIdx =0;
13360    uint8_t arrIdx =0;
13361    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
13362    RRC_Version_t      *rrcVer =NULLP;
13363
13364    if(f1SetRspMsg->protocolIEs.list.array)
13365    {
13366       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
13367       {
13368          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
13369          {
13370             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
13371             {
13372                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13373                   {
13374                      cellToActivate =
13375                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
13376                      if(cellToActivate->list.array)
13377                      {
13378                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
13379                         {
13380                            if(cellToActivate->list.array[arrIdx])
13381                            {
13382
13383                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
13384                               pLMN_Identity.buf)
13385                               {
13386                                  if(cellToActivate->list.array[0]->value.choice.\
13387                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
13388                                  {
13389                                     free(cellToActivate->list.array[0]->value.choice.\
13390                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
13391                                  }
13392
13393                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
13394                                        nRCGI.pLMN_Identity.buf);
13395                               }
13396                               free(cellToActivate->list.array[arrIdx]);
13397                            }
13398                         }
13399                         free(cellToActivate->list.array);
13400                      }
13401                      break;
13402                   }
13403                case ProtocolIE_ID_id_TransactionID:
13404                   {
13405                      break;
13406                   }
13407                case ProtocolIE_ID_id_gNB_CU_Name:
13408                   {
13409                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
13410                      break;
13411                   }
13412                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
13413                   {
13414                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
13415                      if(rrcVer->latest_RRC_Version.buf)
13416                      {
13417                         if(rrcVer->iE_Extensions)
13418                         {
13419                            if(rrcVer->iE_Extensions->list.array)
13420                            {
13421                               if(rrcVer->iE_Extensions->list.array[0])
13422                               {
13423                                  if(rrcVer->iE_Extensions->list.\
13424                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
13425                                  {
13426                                     free(rrcVer->iE_Extensions->list.\
13427                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
13428                                  }
13429                                  free(rrcVer->iE_Extensions->list.array[0]);
13430                               }
13431                               free(rrcVer->iE_Extensions->list.array);
13432                            }
13433                            free(rrcVer->iE_Extensions);
13434                         }
13435                         free(rrcVer->latest_RRC_Version.buf);
13436                      }
13437                      break;
13438
13439                   }
13440                default:
13441                   {
13442                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
13443                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
13444                   }
13445             }
13446             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
13447          }
13448       }
13449       free(f1SetRspMsg->protocolIEs.list.array);
13450    }
13451 }
13452 /******************************************************************
13453  *
13454  * @brief Processes F1 Setup Response sent by CU
13455  *
13456  * @details
13457  *
13458  *    Function : procF1SetupRsp
13459  *
13460  *    Functionality: Processes F1 Setup Response sent by CU
13461  *
13462  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13463  * @return ROK     - success
13464  *         RFAILED - failure
13465  *
13466  * ****************************************************************/
13467 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
13468 {
13469    uint8_t ret = ROK;
13470    uint16_t idx =0;
13471    F1SetupResponse_t *f1SetRspMsg = NULLP;
13472    GNB_CU_Name_t     *cuName = NULLP;
13473    F1SetupRsp  f1SetRspDb;
13474    RRC_Version_t      *rrcVer =NULLP;
13475
13476    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
13477
13478    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
13479    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
13480
13481    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
13482    {
13483       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
13484       {
13485          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13486             {
13487                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
13488                      value.choice.Cells_to_be_Activated_List);
13489                break;
13490             }
13491          case ProtocolIE_ID_id_TransactionID:
13492             {
13493                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
13494                                     value.choice.TransactionID;
13495                break;
13496             }
13497          case ProtocolIE_ID_id_gNB_CU_Name:
13498             {
13499                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
13500                         value.choice.GNB_CU_Name;
13501                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
13502                break;
13503             }
13504          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
13505             {
13506                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
13507                strcpy(f1SetRspDb.rrcVersion.rrcVer,
13508                      (const char*)rrcVer->latest_RRC_Version.buf);
13509                break;
13510             }
13511          default:
13512             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
13513                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
13514       }
13515       duProcF1SetupRsp();
13516    }
13517
13518    freeAperDecodeF1SetupRsp(f1SetRspMsg);
13519
13520    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
13521    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
13522    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
13523    {
13524       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
13525       return RFAILED;
13526    }
13527    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
13528
13529    if(BuildAndSendE2SetupReq() != ROK)
13530    {
13531       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
13532       return RFAILED;
13533    }
13534    return ret;
13535 }
13536 /*******************************************************************
13537 *
13538 * @brief free GNB DU config update ack
13539 *
13540 * @details
13541 *
13542 *    Function : freeAperDecodeGnbDuAck
13543 *
13544 *    Functionality: Processes GNB DU config update ack And
13545 *                     added free part for the memory allocated by aper_decoder
13546 *
13547 * @params[in] F1AP_PDU_t ASN decoded F1AP message
13548 * @return ROK     - success
13549 *         RFAILED - failure
13550 *
13551 * ****************************************************************/
13552
13553 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
13554 {
13555    uint8_t ieIdx = 0;
13556
13557    if(gnbDuAck->protocolIEs.list.array)
13558    {
13559       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
13560       {
13561          if(gnbDuAck->protocolIEs.list.array[ieIdx])
13562          {
13563             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
13564          }
13565       }
13566       free(gnbDuAck->protocolIEs.list.array);
13567    }
13568 }
13569
13570 /*******************************************************************
13571 *
13572 * @brief Building  result of gnb-du config update ack output
13573 *
13574 * @details
13575 *
13576 *    Function : duProcGnbDuCfgUpdAckMsg
13577 *
13578 *    Functionality:
13579 *        Building output of gnb-du config update ack
13580 *
13581 * @params[in] transId
13582 * @return void
13583 *
13584 * ****************************************************************/
13585
13586 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
13587 {
13588    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
13589    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
13590    uint16_t cellId =0, cellIdx =0, crnti=0;
13591    CmLList *f1apPduNode = NULLP;
13592    ReservedF1apPduInfo *f1apPduInfo =NULLP;
13593    F1AP_PDU_t *f1apMsgPdu = NULLP;
13594    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
13595    BIT_STRING_t *cellIdentity=NULLP;
13596    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
13597    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
13598    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
13599
13600    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
13601    f1apPduNode = searchFromReservedF1apPduList(transId);
13602    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
13603    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
13604
13605    if(f1apMsgPdu)
13606    {
13607       if(f1apMsgPdu->choice.initiatingMessage)
13608       {
13609          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
13610          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
13611          {
13612             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
13613             {
13614                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
13615                   {
13616                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
13617                                      Served_Cells_To_Delete_List;
13618                      if(cellsToDelete->list.array)
13619                      {
13620                         if(cellsToDelete->list.array[arrIdx])
13621                         {
13622                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
13623                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
13624                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
13625                            {
13626                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
13627                               bitStringToInt(cellIdentity, &cellId);
13628                            }
13629                         }
13630                      }
13631
13632                      GET_CELL_IDX(cellId, cellIdx);
13633                      if(duCb.actvCellLst[cellIdx] != NULLP)
13634                      {
13635                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
13636                         {
13637                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13638                            ret = duSendCellDeletReq(cellId);
13639                            if(ret == RFAILED)
13640                            {
13641                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
13642                               request for cellId[%d]", cellId);
13643                            }
13644                         }
13645                         else
13646                         {
13647                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
13648                            while(totalActiveUe)
13649                            {
13650                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
13651                               {
13652                                  ueIdx++;
13653                                  continue;
13654                               }
13655
13656                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
13657                               GET_UE_ID(crnti,ueId);
13658                               /* Sending Ue Context release request only for maximum supporting UEs */
13659                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
13660                               if(ret == RFAILED)
13661                               {
13662                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
13663                                  request for cellId[%d]", cellId);
13664                               }
13665                               ueIdx++;
13666                               totalActiveUe--;
13667                            }
13668                         }
13669                      }
13670                      else
13671                      {
13672                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
13673                         ret = RFAILED;
13674                      }
13675                      break;
13676                   }
13677
13678                default:
13679                   break;
13680             }
13681          }
13682       }
13683    }
13684
13685    FreeDUConfigUpdate(f1apMsgPdu);
13686    deleteFromReservedF1apPduList(f1apPduNode);
13687    return ret;
13688 }
13689
13690 /*******************************************************************
13691 *
13692 * @brief Processes GNB DU config update ack
13693 *
13694 * @details
13695 *
13696 *    Function : procF1GNBDUCfgUpdAck
13697 *
13698 *    Functionality: added free part for the memory allocated by aper_decoder
13699 *
13700 * @params[in] F1AP_PDU_t *f1apMsg
13701 * @return void
13702 *
13703 * ****************************************************************/
13704 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
13705 {
13706    uint8_t ieIdx=0,transId=0;
13707    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
13708
13709    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
13710    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
13711
13712    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
13713    {
13714       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
13715       {
13716          case ProtocolIE_ID_id_TransactionID:
13717             {
13718                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
13719                break;
13720             }
13721          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
13722             {
13723                break;
13724             }
13725          default :
13726             {
13727                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
13728                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
13729                break;
13730             }
13731       }
13732    }
13733
13734    duProcGnbDuCfgUpdAckMsg(transId);
13735
13736 #if 0
13737    /* presently we are not supporting F1 Reset from DU to CU , we are only
13738     * supporting F1 Reset from CU to DU */
13739
13740    if(BuildAndSendF1ResetReq() != ROK)
13741    {
13742       return RFAILED;
13743    }
13744 #endif
13745
13746    freeAperDecodeGnbDuAck(gnbDuAck);
13747    return ROK;
13748 }
13749 /******************************************************************
13750 *
13751 * @brief free DL RRC Message Transfer allocated by aper_decoder
13752 *
13753 * @details
13754 *
13755 *    Function : freeAperDecodef1DlRrcMsg
13756 *
13757 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
13758 *
13759 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
13760 * @return ROK     - success
13761 *         RFAILED - failure
13762 *
13763 * ****************************************************************/
13764
13765 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
13766 {
13767    uint8_t ieIdx =0;
13768    RRCContainer_t *rrcContainer = NULLP;
13769
13770    if(f1DlRrcMsg->protocolIEs.list.array)
13771    {
13772       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
13773       {
13774          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
13775          {
13776             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
13777             {
13778                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13779                   break;
13780                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13781                   break;
13782                case ProtocolIE_ID_id_SRBID:
13783                   break;
13784                case ProtocolIE_ID_id_RRCContainer:
13785                   {
13786                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
13787                      free(rrcContainer->buf);
13788                   }
13789                case ProtocolIE_ID_id_ExecuteDuplication:
13790                   break;
13791                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13792                   break;
13793                   break;
13794             }
13795             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
13796          }
13797       }
13798       free(f1DlRrcMsg->protocolIEs.list.array);
13799    }
13800 }
13801 /******************************************************************
13802  *
13803  * @brief Processes DL RRC Message Transfer  sent by CU
13804  *
13805  * @details
13806  *
13807  *    Function : procF1DlRrcMsgTrans
13808  *
13809  *    Functionality: Processes DL RRC Message Transfer sent by CU
13810  *
13811  * @params[in] F1AP_PDU_t ASN decoded F1AP message
13812  * @return ROK     - success
13813  *         RFAILED - failure
13814  *
13815  * ****************************************************************/
13816 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
13817 {
13818    uint8_t  idx, ret;
13819    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
13820    F1DlRrcMsg dlMsg;
13821    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
13822
13823    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
13824    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
13825
13826    ret = ROK;
13827
13828    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
13829    {
13830       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
13831       {
13832          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13833             {
13834                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
13835                break;
13836             }
13837          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13838             {
13839                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
13840                break;
13841             }
13842          case ProtocolIE_ID_id_SRBID:
13843             {
13844                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
13845                break;
13846             }
13847          case ProtocolIE_ID_id_ExecuteDuplication:
13848             dlMsg.execDup = true;
13849             break;
13850
13851          case ProtocolIE_ID_id_RRCContainer:
13852             {
13853                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
13854                {
13855                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
13856                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
13857                   if(dlMsg.rrcMsgPdu)
13858                   {
13859                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
13860                         dlMsg.rrcMsgSize);
13861                   }
13862                   else
13863                   {
13864                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
13865                      return RFAILED;
13866                   }
13867                }
13868                else
13869                {
13870                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
13871                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
13872                   return RFAILED;
13873                }
13874                break;
13875             }
13876          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13877             {
13878                dlMsg.deliveryStatRpt = true;
13879                break;
13880             }
13881          default:
13882             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
13883                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
13884       }
13885    }
13886
13887    ret = duProcDlRrcMsg(&dlMsg);
13888
13889    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
13890    return ret;
13891 }
13892 /*******************************************************************
13893  *
13894 * @brief Builds the DRB to be Setup Mod list
13895 *
13896 * @details
13897 *
13898 *    Function :
13899 *
13900 *    Functionality: Constructs the DRB to be Setup Mod list
13901 *
13902 * @params[in] DRBs_SetupMod_List_t *drbSet
13903 *
13904 * @return ROK     - success
13905 *         RFAILED - failure
13906 *
13907 * ****************************************************************/
13908 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
13909 {
13910    uint8_t srbIdx = 0;
13911    struct SRBs_SetupMod_ItemIEs *srbItemIe;
13912
13913    srbList->list.count = ueCfg->numRlcLcs;
13914    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
13915
13916    DU_ALLOC(srbList->list.array, srbList->list.size);
13917    if(srbList->list.array == NULLP)
13918    {
13919       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
13920       return RFAILED;
13921    }
13922
13923    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
13924    {
13925       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
13926       if(srbList->list.array[srbIdx] == NULLP)
13927       {
13928          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
13929          return RFAILED;
13930       }
13931    }
13932
13933    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
13934    {
13935       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
13936       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
13937       srbItemIe->criticality = Criticality_reject;
13938       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
13939       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
13940       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
13941    }
13942    return ROK;
13943 }
13944
13945 /*******************************************************************
13946  *
13947 * @brief Builds the DRB to be Setup Mod list
13948 *
13949 * @details
13950 *
13951 *    Function :
13952 *
13953 *    Functionality: Constructs the DRB to be Setup Mod list
13954 *
13955 * @params[in] DRBs_SetupMod_List_t *drbSet
13956 *
13957 * @return ROK     - success
13958 *         RFAILED - failure
13959 *
13960 * ****************************************************************/
13961
13962 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
13963 {
13964    uint8_t arrIdx =0;
13965    uint8_t drbCnt =0;
13966    struct DRBs_SetupMod_ItemIEs *drbItemIe;
13967
13968    drbCnt = ueCfg->numDrbSetupMod;
13969
13970    if(!drbCnt)
13971    {
13972       DU_LOG("\nINFO  -->  F1AP : BuildDrbToBeSetupModList(): No DRB information to avaialble to add");
13973       return ROK;
13974    }
13975
13976    drbSet->list.count = drbCnt;
13977    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
13978    DU_ALLOC(drbSet->list.array, drbSet->list.size);
13979    if(drbSet->list.array == NULLP)
13980    {
13981       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
13982       return  RFAILED;
13983    }
13984    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
13985    {
13986       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
13987       if(drbSet->list.array[arrIdx] == NULLP)
13988       {
13989               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
13990               return  RFAILED;
13991       }
13992
13993       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
13994       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
13995       drbItemIe->criticality = Criticality_reject;
13996       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
13997       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
13998       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
13999       &ueCfg->upTnlInfo[arrIdx])!= ROK)
14000       {
14001          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
14002          return RFAILED;
14003       }
14004
14005    }
14006
14007    return ROK;
14008 }
14009 /*******************************************************************
14010 * @brief Free the memory allocated for DRB setup List
14011 *
14012 * @details
14013 *
14014 *    Function : FreeDrbSetupModList
14015 *
14016 *    Functionality:
14017 *       Free the memory allocated for DRB setup list
14018 *
14019 * @params[in] DRBs_Setup_List_t *
14020 * @return void
14021 *
14022 * ****************************************************************/
14023 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
14024 {
14025    uint8_t arrIdx = 0;
14026    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
14027
14028    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
14029    {
14030       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14031       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
14032       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
14033    }
14034    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
14035 }
14036
14037 /*******************************************************************
14038 * @brief Free the memory allocated for SRB setup List
14039 *
14040 * @details
14041 *
14042 *    Function : FreeSrbSetupModList
14043 *
14044 *    Functionality:
14045 *       Free the memory allocated for SRB setup list
14046 *
14047 * @params[in] SRBs_Setup_List_t *
14048 * @return void
14049 *
14050 * ****************************************************************/
14051 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
14052 {
14053    uint8_t srbIdx = 0;
14054
14055    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
14056       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
14057    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
14058 }
14059
14060 /*******************************************************************
14061 * @brief Free the memory allocated for UE Context Mod Response
14062 *
14063 * @details
14064 *
14065 *    Function : FreeUeContextModResp
14066 *
14067 *    Functionality:
14068 *       Free the memory allocated for UE Context Mod Response
14069 *
14070 * @params[in] F1AP_PDU_t *f1apMsg
14071 * @return void
14072 *
14073 * ****************************************************************/
14074
14075 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
14076 {
14077    uint8_t ieIdx;
14078    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
14079    if(f1apMsg)
14080    {
14081       if(f1apMsg->choice.successfulOutcome)
14082       {
14083          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
14084          if(ueContextModifyRes->protocolIEs.list.array)
14085          {
14086             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
14087             {
14088                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
14089                {
14090                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
14091                   {
14092                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14093                         break;
14094                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14095                         break;
14096                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
14097                         {
14098                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
14099                             value.choice.DRBs_SetupMod_List));
14100                             break;
14101                         }
14102                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
14103                         {
14104                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
14105                               SRBs_SetupMod_List));
14106                            break;
14107                         }
14108                   }
14109                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
14110                }
14111
14112             }
14113             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
14114          }
14115          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14116       }
14117       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14118    }
14119 }
14120
14121 /*****************************************************************i
14122 *
14123 * @brief Creating the ue context modifcation response and sending
14124 *
14125 * @details
14126 *
14127 *    Function : BuildAndSendUeContextModRsp
14128 *
14129 *    Functionality:
14130 *         - Creating the ue context modifcation response
14131 *
14132 * @params[in] uint8_t cellId,uint8_t ueId
14133 * @return ROK     - success
14134 *         RFAILED - failure
14135 *
14136 * ****************************************************************/
14137 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
14138 {
14139    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
14140    uint8_t   elementCnt = 0;
14141    uint8_t   ret = RFAILED;
14142    F1AP_PDU_t *f1apMsg = NULLP;
14143    asn_enc_rval_t  encRetVal;
14144    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
14145
14146    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
14147
14148    while(1)
14149    {
14150       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14151       if(f1apMsg == NULLP)
14152       {
14153          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
14154          break;
14155       }
14156
14157       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14158
14159       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14160       if(f1apMsg->choice.successfulOutcome == NULLP)
14161       {
14162          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
14163          break;
14164       }
14165       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
14166       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14167       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
14168
14169       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
14170
14171       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
14172       {
14173          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
14174             elementCnt =3;
14175          else
14176             elementCnt =2;
14177       }
14178       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14179          elementCnt = 5;
14180       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
14181          elementCnt = 2;
14182       ueContextModifyRes->protocolIEs.list.count = elementCnt;
14183       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
14184
14185       /* Initialize the UE context modification members */
14186       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
14187       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
14188       {
14189          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
14190          break;
14191       }
14192
14193       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
14194       {
14195          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
14196          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
14197          {
14198             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
14199             break;
14200          }
14201       }
14202
14203       ieIdx=0;
14204       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14205       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14206       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
14207       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14208       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
14209
14210       ieIdx++;
14211       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14212       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14213       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
14214       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14215       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
14216
14217       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14218       {
14219          ieIdx++;
14220          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
14221          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14222          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
14223          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
14224          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14225       }
14226
14227       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || (ueCb->f1UeDb->actionType == UE_CTXT_MOD))
14228       {
14229          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
14230          {
14231             ieIdx++;
14232             ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
14233             ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14234             ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
14235                                                                               UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
14236             if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14237             {
14238                for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
14239                {
14240                   if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
14241                   {
14242                      memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
14243                   }
14244                }
14245             }
14246             ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
14247                      value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
14248             if(ret != ROK)
14249             {
14250                DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
14251                break;
14252             }
14253          }
14254       }
14255
14256       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
14257       {
14258          ieIdx++;
14259          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
14260          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
14261          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
14262                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
14263          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
14264          {
14265             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
14266             {
14267                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
14268                      sizeof(RlcBearerCfg));
14269             }
14270          }
14271          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
14272                &ueCb->f1UeDb->duUeCfg);
14273          if(ret != ROK)
14274          {
14275             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
14276             break;
14277          }
14278       }
14279
14280       freeF1UeDb(ueCb->f1UeDb);
14281       ueCb->f1UeDb = NULLP;
14282
14283       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14284
14285       /* Encode the F1SetupRequest type as APER */
14286       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14287       encBufSize = 0;
14288       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
14289
14290       /* Encode results */
14291       if(encRetVal.encoded == ENCODE_FAIL)
14292       {
14293          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
14294                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14295          ret = RFAILED;
14296          break;
14297       }
14298       else
14299       {
14300          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
14301          for(int i=0; i< encBufSize; i++)
14302          {
14303             printf("%x",encBuf[i]);
14304          }
14305       }
14306
14307       /* Sending  msg  */
14308       if(sendF1APMsg() != ROK)
14309       {
14310          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
14311          ret = RFAILED;
14312          break;
14313       }
14314       break;
14315    }
14316    FreeUeContextModResp(f1apMsg);
14317    return ret;
14318 }
14319 /*******************************************************************
14320  *
14321  * @brief Deallocating the memory allocated by the aper decoder
14322  *          for QOSInfo
14323  *
14324  * @details
14325  *
14326  *    Function : freeAperDecodeQosInfo
14327  *
14328  *    Functionality:  Deallocating the memory allocated for QOSInfo
14329  *
14330  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
14331  *
14332  * @return void
14333  *
14334  * ****************************************************************/
14335
14336 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
14337 {
14338    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
14339    {
14340       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
14341       {
14342          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
14343          {
14344             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
14345          }
14346          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
14347       }
14348       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
14349    }
14350 }
14351 /*******************************************************************
14352  *
14353  * @brief Deallocating the memory allocated by the aper decoder
14354  *          for UlTnlInfoforDrb
14355  *
14356  * @details
14357  *
14358  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
14359  *
14360  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
14361  *
14362  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
14363  *
14364  * @return void
14365  *
14366  * ****************************************************************/
14367 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
14368 {
14369    uint8_t arrIdx =0;
14370
14371    if(ulInfo->list.array)
14372    {
14373       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
14374       {
14375          if(ulInfo->list.array[arrIdx])
14376          {
14377             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
14378             {
14379                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
14380                {
14381                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
14382                   {
14383                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
14384                            gTP_TEID.buf);
14385                   }
14386                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
14387                         transportLayerAddress.buf);
14388                }
14389                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
14390             }
14391             free(ulInfo->list.array[arrIdx]);
14392          }
14393       }
14394       free(ulInfo->list.array);
14395    }
14396 }
14397 /*******************************************************************
14398  *
14399  * @brief Deallocating the memory allocated by the aper decoder
14400  *          for DrbSetupModItem
14401  *
14402  * @details
14403  *
14404  *    Function : freeAperDecodeDrbSetupModItem
14405  *
14406  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
14407  *
14408  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
14409  *
14410  * @return void
14411  *
14412  * ****************************************************************/
14413
14414 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
14415 {
14416    uint8_t arrIdx =0;
14417    SNSSAI_t *snssai =NULLP;
14418    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
14419
14420    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
14421    switch(drbItem->qoSInformation.present)
14422    {
14423       case QoSInformation_PR_NOTHING:
14424          break;
14425       case QoSInformation_PR_eUTRANQoS:
14426          {
14427             if(drbItem->qoSInformation.choice.eUTRANQoS)
14428             {
14429                free(drbItem->qoSInformation.choice.eUTRANQoS);
14430             }
14431             break;
14432          }
14433       case QoSInformation_PR_choice_extension:
14434          {
14435             if(drbItem->qoSInformation.choice.choice_extension)
14436             {
14437                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
14438                      DRB_Information.dRB_QoS);
14439                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
14440                if(snssai->sST.buf)
14441                {
14442                   free(snssai->sST.buf);
14443                }
14444                if(snssai->sD)
14445                {
14446                   if(snssai->sD->buf)
14447                   {
14448                      free(snssai->sD->buf);
14449                   }
14450                   free(snssai->sD);
14451                }
14452
14453                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
14454                          DRB_Information.flows_Mapped_To_DRB_List;
14455                if(flowMap->list.array)
14456                {
14457                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
14458                   {
14459                      if(flowMap->list.array[arrIdx] )
14460                      {
14461                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
14462                         free(flowMap->list.array[arrIdx]);
14463                      }
14464                   }
14465                   free(flowMap->list.array);
14466                }
14467
14468                free(drbItem->qoSInformation.choice.choice_extension);
14469             }
14470             break;
14471          }
14472
14473    }
14474    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
14475    if(drbItem->uLConfiguration)
14476    {
14477       free(drbItem->uLConfiguration);
14478    }
14479 }
14480
14481 /*******************************************************************
14482  *
14483  * @brief Deallocating the memory allocated by the aper decoder
14484  *          for DrbToBeSetupModList
14485  *
14486  * @details
14487  *
14488  *    Function : freeAperDecodeDrbToBeSetupModList
14489  *
14490  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
14491  *
14492  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
14493  *
14494  * @return void
14495  *
14496  * ****************************************************************/
14497
14498 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
14499 {
14500    uint8_t arrIdx =0;
14501    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
14502
14503    if(drbSet->list.array)
14504    {
14505       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
14506       {
14507          if(drbSet->list.array[arrIdx] != NULLP)
14508          {
14509             if(arrIdx == 0)
14510             {
14511                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
14512                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
14513             }
14514             free(drbSet->list.array[arrIdx]);
14515          }
14516       }
14517       free(drbSet->list.array);
14518    }
14519
14520 }
14521 /*******************************************************************
14522  *
14523  * @brief Deallocating the memory allocated by the aper decoder
14524  *          for UeContextModificationReqMsg
14525  *
14526  * @details
14527  *
14528  *    Function : freeAperDecodeUeContextModificationReqMsg
14529  *
14530  *    Functionality:  Deallocating memory allocated for
14531  *                  UeContextModificationReqMsg
14532  *
14533  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
14534  *
14535  * @return void
14536  *
14537  * ****************************************************************/
14538 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
14539 {
14540    uint8_t arrIdx, ieId;
14541
14542    if(ueContextModifyReq->protocolIEs.list.array)
14543    {
14544       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
14545       {
14546          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
14547          {
14548             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
14549             switch(ieId)
14550             {
14551                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14552                   break;
14553                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14554                   break;
14555                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
14556                   {
14557                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
14558                            value.choice.DRBs_ToBeSetupMod_List);
14559                      break;
14560                   }
14561                case ProtocolIE_ID_id_TransmissionActionIndicator:
14562                   break;
14563                case ProtocolIE_ID_id_RRCContainer:
14564                   {
14565                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
14566                   }
14567             }
14568             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
14569          }
14570       }
14571       free(ueContextModifyReq->protocolIEs.list.array);
14572    }
14573 }
14574 /*******************************************************************
14575  *
14576  * @brief processing the F1 UeContextModificationReq
14577  *
14578  * @details
14579  *
14580  *    Function : procF1UeContextModificationReq
14581  *
14582  *    Functionality:  processing the F1 UeContextModificationReq
14583  *
14584  * @params[in] F1AP_PDU_t *f1apMsg
14585  *
14586  * @return
14587  * ****************************************************************/
14588 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
14589 {
14590    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
14591    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
14592    DuUeCb   *duUeCb = NULLP;
14593    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
14594    DRBs_ToBeModified_List_t *drbModifiedCfg;
14595    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
14596
14597    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
14598    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
14599    {
14600       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
14601       {
14602          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14603             {
14604                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
14605                break;
14606             }
14607          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14608             {
14609                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
14610                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
14611                {
14612                   if(duCb.actvCellLst[cellIdx])
14613                   {
14614                      for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
14615                      {
14616                         if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
14617                               (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
14618                         {
14619                            duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
14620                            if(duUeCb->f1UeDb == NULLP)
14621                            {
14622                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
14623                               duUeCb->f1UeDb->cellIdx = cellIdx;
14624                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
14625                            }
14626                            break;
14627                         }
14628                      }
14629                   }
14630                }
14631                if(duUeCb == NULLP)
14632                {
14633                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
14634                   ret = RFAILED;
14635                }
14636                break;
14637             }
14638
14639          case ProtocolIE_ID_id_RRCContainer:
14640             {
14641                /* Filling Dl RRC Msg Info */
14642                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
14643                if(!duUeCb->f1UeDb->dlRrcMsg)
14644                {
14645                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
14646                         Memory allocation failed ");
14647                   ret = RFAILED;
14648                }
14649                else
14650                {
14651                   duUeCb->f1UeDb->dlRrcMsgPres = true;
14652                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
14653                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
14654                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
14655                         value.choice.RRCContainer);
14656                }
14657
14658                break;
14659             }
14660
14661          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
14662          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
14663             {
14664                if(duUeCb->f1UeDb)
14665                {
14666                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
14667                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
14668                   {
14669                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
14670                                       choice.DRBs_ToBeSetupMod_List;
14671
14672                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
14673                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
14674                      {
14675                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
14676                         ret = RFAILED;
14677                      }
14678                   }
14679
14680                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
14681                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
14682
14683                   {
14684                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
14685                                       choice.DRBs_ToBeModified_List;
14686                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
14687                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
14688                      {
14689                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
14690                         ret = RFAILED;
14691                      }
14692                   }
14693                }
14694                break;
14695             }
14696
14697          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
14698             {
14699                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
14700                if(duUeCb->f1UeDb)
14701                {
14702                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
14703                }
14704                break;
14705             }
14706
14707          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
14708             {
14709                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
14710                   RRCReconfigurationCompleteIndicator_true)
14711                {
14712                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
14713                }
14714                break;
14715             }
14716          case ProtocolIE_ID_id_TransmissionActionIndicator:
14717             {
14718                if(duUeCb->f1UeDb)
14719                {
14720                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
14721                   {
14722                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
14723                   }
14724                   else
14725                   {
14726                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
14727                   }
14728                }
14729                break;
14730             }
14731
14732          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
14733             {
14734                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
14735                {
14736                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
14737                }
14738                break;
14739             }
14740
14741       }
14742    }
14743
14744    if(ret != RFAILED)
14745    {
14746       ret = duProcUeContextModReq(duUeCb);
14747    }
14748    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
14749    return ret;
14750 }
14751
14752 /*****************************************************************i
14753 *
14754 * @brief Free memory allocated for UE Context Release Request
14755 *
14756 * @details
14757 *
14758 *    Function : FreeUeContextReleaseReq
14759 *
14760 *    Functionality:
14761 *         - Free memory allocated for UE Context Release Request
14762 *
14763 * @params[in] F1AP_PDU_t *f1apMsg
14764 * @return void
14765 *
14766 * *************************************************************/
14767 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
14768 {
14769    uint8_t ieIdx;
14770    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
14771
14772    if(f1apMsg)
14773    {
14774       if(f1apMsg->choice.initiatingMessage)
14775       {
14776          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
14777          if(ueReleaseReq->protocolIEs.list.array)
14778          {
14779             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
14780             {
14781                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
14782             }
14783             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
14784          }
14785          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14786       }
14787       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14788    }
14789
14790 }
14791 /*****************************************************************i
14792 *
14793 * @brief Build and Send UE Context Release Request
14794 *
14795 * @details
14796 *
14797 *    Function : BuildAndSendUeContextReleaseReq
14798 *
14799 *    Functionality:
14800 *         - Build and Send UE Context Release Request
14801 *
14802 * @params[in]
14803 * @return ROK     - success
14804 *         RFAILED - failure
14805 *
14806 * *************************************************************/
14807 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
14808 {
14809    bool memAllocFail = false;
14810    uint8_t ieIdx =0;
14811    uint8_t ret = RFAILED;
14812    uint16_t cellIdx =0;
14813    uint16_t crnti = 0;
14814    uint8_t  elementCnt = 0;
14815    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
14816    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
14817    asn_enc_rval_t encRetVal;
14818    F1AP_PDU_t *f1apMsg = NULLP;
14819    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
14820
14821    DU_LOG("\nINFO  --> Building the UE Context Release Request");
14822    do
14823    {
14824       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14825       if(f1apMsg == NULLP)
14826       {
14827          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
14828          break;
14829       }
14830
14831       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14832       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14833       if(f1apMsg->choice.initiatingMessage == NULLP)
14834       {
14835          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
14836          initiatingMessage");
14837          break;
14838       }
14839       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
14840       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14841       f1apMsg->choice.initiatingMessage->value.present = \
14842       InitiatingMessage__value_PR_UEContextReleaseRequest;
14843
14844       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
14845
14846       elementCnt = 2;
14847
14848       ueReleaseReq->protocolIEs.list.count = elementCnt;
14849       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
14850
14851       /* Initialize the F1Setup members */
14852       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
14853       if(ueReleaseReq->protocolIEs.list.array == NULLP)
14854       {
14855          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
14856          break;
14857       }
14858       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
14859       {
14860          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
14861                sizeof(UEContextReleaseRequest_t));
14862          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
14863          {
14864             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
14865             memAllocFail = true;
14866             break;
14867          }
14868       }
14869       if(memAllocFail == true)
14870          break;
14871
14872       /* Fetching Ue Cb Info*/
14873       GET_CELL_IDX(cellId, cellIdx);
14874       if(duCb.actvCellLst[cellIdx] == NULLP)
14875       {
14876          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
14877          break;
14878       }
14879       else
14880       {
14881          GET_CRNTI(crnti, ueId);
14882          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
14883          {
14884             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
14885             break;
14886          }
14887          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14888          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14889       }
14890
14891       ieIdx=0;
14892       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14893       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14894       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
14895       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
14896       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
14897
14898       ieIdx++;
14899       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14900       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
14901       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
14902       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
14903       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
14904
14905       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14906
14907       /* Encode the F1SetupRequest type as APER */
14908       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14909       encBufSize = 0;
14910       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14911       /* Encode results */
14912       if(encRetVal.encoded == ENCODE_FAIL)
14913       {
14914          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
14915                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14916          break;
14917       }
14918       else
14919       {
14920          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
14921          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
14922          {
14923             printf("%x",encBuf[ieIdx]);
14924          }
14925       }
14926
14927       /* Sending msg */
14928       if(sendF1APMsg() != ROK)
14929       {
14930          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
14931          break;
14932       }
14933       ret = ROK;
14934       break;
14935    }while(true);
14936
14937    FreeUeContextReleaseReq(f1apMsg);
14938    return ret;
14939 }
14940 /*****************************************************************i
14941  *
14942  * @brief Free memory allocated for UE Context Release Complete
14943  *
14944  * @details
14945  *
14946  *    Function : FreeUeContextReleaseComplete
14947  *
14948  *    Functionality:
14949  *         - Free memory allocated for UE Context Release Complete
14950  *
14951  * @params[in] F1AP_PDU_t *f1apMsg
14952  * @return void
14953  *
14954  * *************************************************************/
14955 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
14956 {
14957    uint8_t ieIdx;
14958    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
14959
14960    if(f1apMsg)
14961    {
14962       if(f1apMsg->choice.successfulOutcome)
14963       {
14964          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
14965          if(ueReleaseComplete->protocolIEs.list.array)
14966          {
14967             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
14968             {
14969                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
14970             }
14971             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
14972          }
14973          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14974       }
14975       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14976    }
14977
14978 }
14979 /*****************************************************************i
14980  *
14981  * @brief Build and Send UE Context Release Complete
14982  *
14983  * @details
14984  *
14985  *    Function : BuildAndSendUeContextReleaseComplete
14986  *
14987  *    Functionality:
14988  *         - Build and Send UE Context Release Complete
14989  *
14990  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
14991  * @return ROK     - success
14992  *         RFAILED - failure
14993  *
14994  * *************************************************************/
14995 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
14996 {
14997    bool memAllocFail = false;
14998    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
14999    asn_enc_rval_t encRetVal;
15000    F1AP_PDU_t *f1apMsg = NULLP;
15001    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
15002
15003    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
15004    do
15005    {
15006       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15007       if(f1apMsg == NULLP)
15008       {
15009          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
15010          break;
15011       }
15012
15013       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
15014       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15015       if(f1apMsg->choice.successfulOutcome == NULLP)
15016       {
15017          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
15018                successfulOutcome");
15019          break;
15020       }
15021       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
15022       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
15023       f1apMsg->choice.successfulOutcome->value.present = \
15024       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
15025
15026       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
15027
15028       elementCnt = 2;
15029       ueReleaseComplete->protocolIEs.list.count = elementCnt;
15030       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
15031
15032       /* Initialize the UE Release Complete members */
15033       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
15034       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
15035       {
15036          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
15037          break;
15038       }
15039       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
15040       {
15041          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
15042                sizeof(UEContextReleaseComplete_t));
15043          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
15044          {
15045             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
15046             elements");
15047             memAllocFail = true;
15048             break;
15049          }
15050       }
15051       if(memAllocFail == true)
15052          break;
15053
15054
15055       ieIdx=0;
15056       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15057       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
15058       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
15059       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
15060       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
15061
15062       ieIdx++;
15063       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15064       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
15065       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
15066       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
15067       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
15068
15069       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15070
15071       /* Encode the F1SetupComplete type as APER */
15072       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15073       encBufSize = 0;
15074       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
15075       /* Encode results */
15076       if(encRetVal.encoded == ENCODE_FAIL)
15077       {
15078          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
15079                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15080          break;
15081       }
15082       else
15083       {
15084          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
15085          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
15086          {
15087             printf("%x",encBuf[ieIdx]);
15088          }
15089       }
15090
15091       /* Sending msg */
15092       if(sendF1APMsg() != ROK)
15093       {
15094          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
15095          break;
15096       }
15097       ret = ROK;
15098       break;
15099    }while(true);
15100
15101    if(ret == ROK && duCb.actvCellLst[cellId-1] && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
15102    {
15103       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
15104       ret = duSendCellDeletReq(cellId);
15105       if(ret != ROK)
15106       {
15107          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
15108                Delete req for CellId");
15109       }
15110    }
15111    FreeUeContextReleaseComplete(f1apMsg);
15112    return ret;
15113
15114 }
15115
15116 /*******************************************************************
15117 *
15118 * @brief added free part for the memory allocated by aper_decoder
15119 *
15120 * @details
15121 *
15122 *    Function : freeAperDecodeUeContextReleaseCommand
15123 *
15124 *    Functionality: added free part for the memory allocated by aper_decoder
15125 *
15126 * @params[in] F1AP_PDU_t *f1apMsg
15127 * @return void
15128 *
15129 * ****************************************************************/
15130 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
15131 {
15132    uint8_t ieIdx=0;
15133    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
15134
15135    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
15136
15137    if(ueContextReleaseCommand->protocolIEs.list.array)
15138    {
15139       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
15140       {
15141          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
15142          {
15143             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
15144             {
15145                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15146                   break;
15147                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15148                   break;
15149                case ProtocolIE_ID_id_Cause:
15150                   break;
15151                case ProtocolIE_ID_id_RRCContainer:
15152                {
15153                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
15154                   {
15155                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
15156                   }
15157                   break;
15158                }
15159                default :
15160                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
15161                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
15162                   break;
15163             }
15164          }
15165          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
15166       }
15167       free(ueContextReleaseCommand->protocolIEs.list.array);
15168    }
15169 }
15170 /*******************************************************************
15171 *
15172 * @brief processing of UE Context Release Command
15173 *
15174 * @details
15175 *
15176 *    Function : procF1UeContextReleaseCommand
15177 *
15178 *    Functionality: processing of UE Context Release Command
15179 *
15180 * @params[in] F1AP_PDU_t *f1apMsg
15181 * @return void
15182 *
15183 * ****************************************************************/
15184 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
15185 {
15186    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
15187    uint16_t cellIdx =0, cellId = 0;
15188    bool ueIdxFound = false;
15189    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
15190    DuUeCb   *duUeCb = NULLP;
15191    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
15192
15193    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
15194
15195    if(ueContextReleaseCommand->protocolIEs.list.array)
15196    {
15197       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
15198       {
15199          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
15200          {
15201             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
15202             {
15203                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15204                   {
15205                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15206                                     value.choice.GNB_CU_UE_F1AP_ID;
15207                      break;
15208                   }
15209
15210                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15211                   {
15212                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15213                                      value.choice.GNB_DU_UE_F1AP_ID;
15214                      break;
15215                   }
15216
15217                case ProtocolIE_ID_id_Cause:
15218                   {
15219                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
15220                      {
15221                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
15222                         {
15223                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
15224                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
15225                            {
15226                               cellId = duCb.actvCellLst[cellIdx]->cellId;
15227                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
15228                               ueIdxFound = true;
15229                               break;
15230                            }
15231                         }
15232                         if(ueIdxFound == true)
15233                         {
15234                            break;
15235                         }
15236                      }
15237
15238                      if(!ueIdxFound)
15239                      {
15240                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
15241                         ret = RFAILED;
15242                      }
15243                      break;
15244                   }
15245
15246                case ProtocolIE_ID_id_RRCContainer:
15247                   {
15248                      if(ueIdxFound == true)
15249                      {
15250                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
15251                         if(duUeCb->f1UeDb)
15252                         {
15253                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
15254                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
15255                            duUeCb->f1UeDb->cellIdx = cellIdx;
15256                            /* Filling Dl RRC Msg Info */
15257                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
15258                            if(!duUeCb->f1UeDb->dlRrcMsg)
15259                            {
15260                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
15261                                     Memory allocation failed ");
15262                               ret = RFAILED;
15263                            }
15264                            else
15265                            {
15266                               duUeCb->f1UeDb->dlRrcMsgPres = true;
15267                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
15268                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
15269                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
15270                                     value.choice.RRCContainer);
15271                            }
15272
15273                         }
15274                         else
15275                         {
15276                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
15277                                  Memory allocation failed ");
15278                            ret = RFAILED;
15279
15280                         }
15281                      }
15282                      break;
15283                   }
15284                default :
15285                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
15286                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
15287                   break;
15288             }
15289          }
15290       }
15291    }
15292    if(ret != RFAILED)
15293    {
15294       duProcUeContextReleaseCommand(cellId, duUeCb);
15295    }
15296    freeAperDecodeUeContextReleaseCommand(f1apMsg);
15297    return ret;
15298 }
15299 /**************************************************************
15300  *
15301  * @brief Handles received F1AP message and sends back response
15302  *
15303  * @details
15304  *
15305  *    Function : F1APMsgHdlr
15306  *
15307  *    Functionality:
15308  *         - Decodes received F1AP control message
15309  *         - Prepares response message, encodes and sends to SCTP
15310  *
15311  * @params[in]
15312  * @return ROK     - success
15313  *         RFAILED - failure
15314  *
15315  * ****************************************************************/
15316 void F1APMsgHdlr(Buffer *mBuf)
15317 {
15318    int i =0;
15319    char *recvBuf =NULLP;
15320    MsgLen copyCnt =0;
15321    MsgLen recvBufLen =0;
15322    F1AP_PDU_t *f1apMsg =NULLP;
15323    asn_dec_rval_t rval; /* Decoder return value */
15324    F1AP_PDU_t f1apasnmsg ;
15325    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
15326    ODU_PRINT_MSG(mBuf, 0,0);
15327
15328    /* Copy mBuf into char array to decode it */
15329    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
15330    DU_ALLOC(recvBuf, (Size)recvBufLen);
15331
15332    if(recvBuf == NULLP)
15333    {
15334       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
15335       return;
15336    }
15337    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
15338    {
15339       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
15340       return;
15341    }
15342
15343    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
15344    for(i=0; i< recvBufLen; i++)
15345    {
15346       printf("%x",recvBuf[i]);
15347    }
15348
15349    /* Decoding flat buffer into F1AP messsage */
15350    f1apMsg = &f1apasnmsg;
15351    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
15352
15353    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
15354
15355    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
15356    {
15357       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
15358       return;
15359    }
15360    printf("\n");
15361    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15362
15363    switch(f1apMsg->present)
15364    {
15365       case F1AP_PDU_PR_successfulOutcome:
15366          {
15367             switch(f1apMsg->choice.successfulOutcome->value.present)
15368             {
15369                case SuccessfulOutcome__value_PR_ResetAcknowledge:
15370                   {
15371                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
15372                      break;
15373                   }
15374                case SuccessfulOutcome__value_PR_F1SetupResponse:
15375                   {
15376 #ifndef ODU_TEST_STUB
15377                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
15378 #endif
15379                      break;
15380                   }
15381
15382                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
15383                   {
15384                      procF1GNBDUCfgUpdAck(f1apMsg);
15385                      break;
15386                   }
15387
15388                default:
15389                   {
15390                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
15391                            f1apMsg->choice.successfulOutcome->value.present);
15392                      return;
15393                   }
15394             }/* End of switch(successfulOutcome) */
15395             free(f1apMsg->choice.successfulOutcome);
15396             break;
15397          }
15398       case F1AP_PDU_PR_initiatingMessage:
15399          {
15400             switch(f1apMsg->choice.initiatingMessage->value.present)
15401             {
15402                case InitiatingMessage__value_PR_Reset:
15403                   {
15404                      procF1ResetReq(f1apMsg);
15405                      break;
15406                   }
15407                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
15408                   {
15409                      procF1DlRrcMsgTrans(f1apMsg);
15410                      break;
15411                   }
15412                case InitiatingMessage__value_PR_UEContextSetupRequest:
15413                   {
15414                      procF1UeContextSetupReq(f1apMsg);
15415                      break;
15416                   }
15417                case InitiatingMessage__value_PR_UEContextModificationRequest:
15418                   {
15419                      procF1UeContextModificationReq(f1apMsg);
15420                      break;
15421                   }
15422                case InitiatingMessage__value_PR_UEContextReleaseCommand:
15423                   {
15424                       procF1UeContextReleaseCommand(f1apMsg);
15425                       break;
15426                   }
15427                default:
15428                   {
15429                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
15430                            f1apMsg->choice.initiatingMessage->value.present);
15431                      return;
15432                   }
15433             }/* End of switch(initiatingMessage) */
15434             free(f1apMsg->choice.initiatingMessage);
15435             break;
15436          }
15437
15438       default:
15439          {
15440             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
15441             return;
15442          }
15443          free(f1apMsg);
15444
15445    }/* End of switch(f1apMsg->present) */
15446
15447    DU_FREE(recvBuf, (Size)recvBufLen);
15448 } /* End of F1APMsgHdlr */
15449
15450 /**********************************************************************
15451   End of file
15452  **********************************************************************/