src/cu_stub/cu_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "cu_stub_sctp.h"
  25 #include "cu_f1ap_msg_hdl.h"
  26
  27 /*******************************************************************
  28 *
  29 * @brief Sends F1 msg over SCTP
  30 *
  31 * @details
  32 *
  33 *    Function : SendF1APMsg
  34 *
  35 *    Functionality: Sends F1 msg over SCTP
  36 *
  37 * @params[in] Region region
  38 *             Pool pool
  39 * @return ROK     - success
  40 *         RFAILED - failure
  41 *
  42 * ****************************************************************/
  43 S16 SendF1APMsg(Region region, Pool pool)
  44 {
  45    Buffer *mBuf = NULLP;
  46
  47    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
  48    {
  49       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
  50       {
  51          ODU_PRINT_MSG(mBuf, 0,0);
  52
  53          if(sctpSend(mBuf) != ROK)
  54          {
  55             DU_LOG("\nF1AP : SCTP Send failed");
  56             ODU_PUT_MSG_BUF(mBuf);
  57             return RFAILED;
  58          }
  59       }
  60       else
  61       {
  62          DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
  63          ODU_PUT_MSG_BUF(mBuf);
  64          return RFAILED;
  65       }
  66       ODU_PUT_MSG_BUF(mBuf);
  67    }
  68    else
  69    {
  70       DU_LOG("\nF1AP : Failed to allocate memory");
  71       return RFAILED;
  72    }
  73
  74    return ROK;
  75 } /* SendF1APMsg */
  76
  77 /*******************************************************************
  78  *
  79  * @brief Builds NRCell ID
  80  *
  81  * @details
  82  *
  83  *    Function : BuildNrCellId
  84  *
  85  *    Functionality: Building the NR Cell ID
  86  *
  87  * @params[in] BIT_STRING_t *nrcell
  88  * @return ROK     - success
  89  *         RFAILED - failure
  90  *
  91  * ****************************************************************/
  92
  93 S16 BuildNrCellId(BIT_STRING_t *nrcell)
  94 {
  95    U8 tmp;
  96    for (tmp = 0 ; tmp < nrcell->size-1; tmp++)
  97    {
  98       nrcell->buf[tmp] = 0;
  99    }
 100    nrcell->buf[4]   = 16;
 101    nrcell->bits_unused = 4;
 102    nrcell->size = 5 * sizeof(uint8_t);
 103    return ROK;
 104 }
 105
 106 /********************************************************************
 107  *
 108  * @brief Builds and sends the F1SetupResponse
 109  *
 110  * @details
 111  *
 112  *    Function : BuildAndSendF1SetupRsp
 113  *
 114  *    Functionality: Constructs the F1SetupResponse message and sends
 115  *                   it back to the DU through SCTP.
 116  *
 117  * @params[in] void **buf,Buffer to which encoded pattern is written into
 118  * @params[in] int *size,size of buffer
 119  *
 120  * @return ROK     - success
 121  *         RFAILED - failure
 122  *
 123  * ****************************************************************/
 124 S16 BuildAndSendF1SetupRsp()
 125 {
 126    U8    idx,ieIdx;
 127    U8    elementCnt,cellCnt;
 128    F1AP_PDU_t         *f1apMsg = NULL;
 129    F1SetupResponse_t  *f1SetupRsp;
 130    GNB_CU_Name_t      *cuName;
 131    Cells_to_be_Activated_List_t *cellToActivate;
 132    RRC_Version_t      *rrcVer;
 133    asn_enc_rval_t     encRetVal;
 134    DU_LOG("\nF1AP : Building F1 Setup Response\n");
 135
 136    /* Allocate the memory for F1SetupRequest_t */
 137    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 138    if(f1apMsg == NULLP)
 139    {
 140       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 141       return RFAILED;
 142    }
 143    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 144
 145    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 146    if(f1apMsg->choice.successfulOutcome == NULLP)
 147    {
 148       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 149       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 150       return RFAILED;
 151    }
 152
 153    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 154    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 155    f1apMsg->choice.successfulOutcome->value.present = \
 156                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 157    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 158
 159    elementCnt = 4;
 160    f1SetupRsp->protocolIEs.list.count = elementCnt;
 161    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 162
 163    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 164          elementCnt * sizeof(F1SetupResponseIEs_t *));
 165    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 166    {
 167       DU_LOG("\nF1AP : Memory allocation for F1ResponseIEs failed");
 168       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 169       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 170       return RFAILED;
 171    }
 172
 173    for(idx=0; idx<elementCnt; idx++)
 174    {
 175       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 176             sizeof(F1SetupResponseIEs_t));
 177       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 178       {
 179          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 180                elementCnt * sizeof(F1SetupResponseIEs_t *));
 181          CU_FREE(f1apMsg->choice.successfulOutcome, \
 182                sizeof(SuccessfulOutcome_t));
 183          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 184          return RFAILED;
 185       }
 186    }
 187
 188    /*TransactionID*/
 189    idx = 0;
 190    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 191    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 192    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 193                                                             F1SetupResponseIEs__value_PR_TransactionID;
 194    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 195                                                                         TRANS_ID;
 196
 197    /*CU Name*/
 198    idx++;
 199    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 200    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 201    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 202                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 203    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 204    cuName->size = sizeof(cuCfgParams.cuName);
 205
 206    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 207    if(cuName->buf == NULLP)
 208    {
 209       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 210       {
 211          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 212                sizeof(F1SetupResponseIEs_t));
 213       }
 214       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 215             elementCnt * sizeof(F1SetupResponseIEs_t *));
 216       CU_FREE(f1apMsg->choice.successfulOutcome,\
 217             sizeof(SuccessfulOutcome_t));
 218       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 219       return RFAILED;
 220    }
 221    strcpy((char*)cuName->buf, (char*)cuCfgParams.cuName);
 222
 223    /*Cells to be activated list*/
 224    idx++;
 225    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 226                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 227    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 228    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 229                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 230    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 231                     Cells_to_be_Activated_List;
 232    cellCnt=1;
 233    cellToActivate->list.count = cellCnt;
 234    cellToActivate->list.size = \
 235                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 236    CU_ALLOC(cellToActivate->list.array,\
 237          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 238    if(cellToActivate->list.array == NULLP)
 239    {
 240       CU_FREE(cuName->buf, sizeof(cuName->size));
 241       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 242       {
 243          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 244                sizeof(F1SetupResponseIEs_t));
 245       }
 246       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 247             elementCnt * sizeof(F1SetupResponseIEs_t *));
 248       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 249       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 250       return RFAILED;
 251    }
 252    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 253    {
 254       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 255       if(cellToActivate->list.array[ieIdx] == NULLP)
 256       {
 257          CU_FREE(cellToActivate->list.array,\
 258                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 259          CU_FREE(cuName->buf, sizeof(cuName->size));
 260          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 261          {
 262             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 263                   sizeof(F1SetupResponseIEs_t));
 264          }
 265          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 266                elementCnt * sizeof(F1SetupResponseIEs_t *));
 267          CU_FREE(f1apMsg->choice.successfulOutcome, \
 268                sizeof(SuccessfulOutcome_t));
 269          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 270          return RFAILED;
 271       }
 272    }
 273    cellToActivate->list.array[0]->id = \
 274                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 275    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 276    cellToActivate->list.array[0]->value.present = \
 277                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 278    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 279       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 280    CU_ALLOC(cellToActivate->list.array[0]->\
 281          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 282          3*sizeof(uint8_t));
 283    if(cellToActivate->list.array[0]->value.choice.\
 284          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 285    {
 286
 287       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 288       {
 289          CU_FREE(cellToActivate->list.array[ieIdx],\
 290                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 291       }
 292
 293       CU_FREE(cellToActivate->list.array,\
 294             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 295       CU_FREE(cuName->buf, sizeof(cuName->size));
 296       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 297       {
 298          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 299                sizeof(F1SetupResponseIEs_t));
 300       }
 301       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 302             elementCnt * sizeof(F1SetupResponseIEs_t *));
 303       CU_FREE(f1apMsg->choice.successfulOutcome, \
 304             sizeof(SuccessfulOutcome_t));
 305       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 306       return RFAILED;
 307    }
 308    buildPlmnId(cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 309          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 310    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 311       nRCGI.nRCellIdentity.size = 5;
 312    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 313          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 314          5*sizeof(uint8_t));
 315    if(cellToActivate->list.array[0]->value.choice.\
 316          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 317    {
 318       CU_FREE(cellToActivate->list.array[0]->\
 319             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 320             3*sizeof(uint8_t));
 321       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 322       {
 323          CU_FREE(cellToActivate->list.array[ieIdx],\
 324                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 325       }
 326
 327       CU_FREE(cellToActivate->list.array,\
 328             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 329       CU_FREE(cuName->buf, sizeof(cuName->size));
 330       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 331       {
 332          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 333                sizeof(F1SetupResponseIEs_t));
 334       }
 335       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 336             elementCnt * sizeof(F1SetupResponseIEs_t *));
 337       CU_FREE(f1apMsg->choice.successfulOutcome, \
 338             sizeof(SuccessfulOutcome_t));
 339       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 340       return RFAILED;
 341    }
 342    BuildNrCellId(&(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity));
 343    /* RRC Version */
 344    idx++;
 345    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 346                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 347    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 348    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 349                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 350    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 351    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 352
 353    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 354    if(rrcVer->latest_RRC_Version.buf == NULLP)
 355    {
 356       CU_FREE(cuName->buf, sizeof(cuName->size));
 357       for(ieIdx=0; ieIdx<elementCnt; idx++)
 358       {
 359          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 360                sizeof(F1SetupResponseIEs_t));
 361       }
 362       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 363             elementCnt * sizeof(F1SetupResponseIEs_t *));
 364       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 365       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 366       return RFAILED;
 367    }
 368
 369    /* Need to check RRC Version */
 370    rrcVer->latest_RRC_Version.buf[0] = cuCfgParams.rrcVersion.rrcVer;
 371    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 372    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 373    if(rrcVer->iE_Extensions == NULLP)
 374    {
 375       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 376       CU_FREE(cuName->buf, sizeof(cuName->size));
 377       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 378       {
 379          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 380                sizeof(F1SetupResponseIEs_t));
 381       }
 382       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 383             elementCnt * sizeof(F1SetupResponseIEs_t *));
 384       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 385       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 386       return RFAILED;
 387    }
 388    rrcVer->iE_Extensions->list.count = 1;
 389    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 390    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 391          sizeof(struct RRC_Version_ExtIEs *));
 392    if(rrcVer->iE_Extensions->list.array == NULLP)
 393    {
 394       CU_FREE(rrcVer->iE_Extensions,\
 395             sizeof(ProtocolExtensionContainer_4624P81_t));
 396       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 397       CU_FREE(cuName->buf, sizeof(cuName->size));
 398       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 399       {
 400          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 401                sizeof(F1SetupResponseIEs_t));
 402       }
 403       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 404             elementCnt * sizeof(F1SetupResponseIEs_t *));
 405       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 406       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 407       return RFAILED;
 408    }
 409    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 410          sizeof(struct RRC_Version_ExtIEs));
 411    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 412    {
 413       CU_FREE(rrcVer->iE_Extensions->list.array,\
 414             sizeof(struct RRC_Version_ExtIEs *));
 415       CU_FREE(rrcVer->iE_Extensions,\
 416             sizeof(ProtocolExtensionContainer_4624P81_t));
 417       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 418       CU_FREE(cuName->buf, sizeof(cuName->size));
 419       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 420       {
 421          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 422                sizeof(F1SetupResponseIEs_t));
 423       }
 424       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 425             elementCnt * sizeof(F1SetupResponseIEs_t *));
 426       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 427       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 428       return RFAILED;
 429    }
 430    rrcVer->iE_Extensions->list.array[0]->id = \
 431                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 432    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 433    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 434                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 435    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 436       Latest_RRC_Version_Enhanced.size = 3*sizeof(U8);
 437    CU_ALLOC(rrcVer->iE_Extensions->list.\
 438          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 439          3*sizeof(U8));
 440    if(rrcVer->iE_Extensions->list.\
 441          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 442    {
 443       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 444             sizeof(struct RRC_Version_ExtIEs));
 445       CU_FREE(rrcVer->iE_Extensions->list.array,\
 446             sizeof(struct RRC_Version_ExtIEs *));
 447       CU_FREE(rrcVer->iE_Extensions,\
 448             sizeof(ProtocolExtensionContainer_4624P81_t));
 449       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 450       CU_FREE(cuName->buf, sizeof(cuName->size));
 451       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 452       {
 453          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 454                sizeof(F1SetupResponseIEs_t));
 455       }
 456       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 457             elementCnt * sizeof(F1SetupResponseIEs_t *));
 458       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 459       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 460       return RFAILED;
 461    }
 462    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 463       Latest_RRC_Version_Enhanced.buf[0] = 0;
 464    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 465       Latest_RRC_Version_Enhanced.buf[1] = 5;
 466    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 467       Latest_RRC_Version_Enhanced.buf[2] = 15;
 468
 469    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 470
 471    /* Encode the F1SetupRequest type as UPER */
 472    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 473    encBufSize = 0;
 474    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 475
 476    /* Clean up */
 477    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 478    CU_FREE(cuName->buf, sizeof(cuName->size));
 479    for(idx=0; idx<elementCnt; idx++)
 480    {
 481       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 482    }
 483    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 484    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 485    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 486
 487    /* Check encode results */
 488    if(encRetVal.encoded == ENCODE_FAIL)
 489    {
 490       DU_LOG("\nF1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 491             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 492       return RFAILED;
 493    }
 494    else
 495    {
 496       DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupResponse\n");
 497       for(int i=0; i< encBufSize; i++)
 498       {
 499          printf("%x",encBuf[i]);
 500       }
 501    }
 502
 503    /* Sending msg */
 504    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 505    {
 506       DU_LOG("\nF1AP : Sending F1 Setup Response failed");
 507       return RFAILED;
 508    }
 509
 510    return ROK;
 511 }/* End of BuildAndSendF1SetupRsp */
 512
 513 /*******************************************************************
 514  *
 515  * @brief Builds and sends the DUUpdateAcknowledge
 516  *
 517  * @details
 518  *
 519  *    Function : BuildAndSendDUUpdateAck
 520  *
 521  *    Functionality: Constructs the DU Update Acknowledge message and sends
 522  *                   it to the DU through SCTP.
 523  *
 524  * @params[in] void **buf,Buffer to which encoded pattern is written into
 525  * @params[in] int *size,size of buffer
 526  *
 527  * @return ROK     - success
 528  *         RFAILED - failure
 529  *
 530  * ****************************************************************/
 531
 532 S16 BuildAndSendDUUpdateAck()
 533 {
 534    U8   idx;
 535    U8   elementCnt;
 536    F1AP_PDU_t *f1apMsg = NULL;
 537    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 538    asn_enc_rval_t enRetVal; /* Encoder return value */
 539
 540    DU_LOG("\nF1AP : Building GNB-DU Config Update Ack\n");
 541
 542    /* Allocate the memory for F1SetupRequest_t */
 543    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 544    if(f1apMsg == NULLP)
 545    {
 546       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 547       return RFAILED;
 548    }
 549
 550    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 551
 552    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 553    if(f1apMsg->choice.successfulOutcome == NULLP)
 554    {
 555       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 556       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 557       return RFAILED;
 558    }
 559
 560    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 561    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 562    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 563    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 564
 565    elementCnt = 1;
 566    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 567    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 568
 569    /* Initialize the F1Setup members */
 570    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 571    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 572    {
 573       DU_LOG("\nF1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 574       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 575       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 576       return RFAILED;
 577    }
 578
 579    for(idx=0; idx<elementCnt; idx++)
 580    {
 581       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 582       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 583       {
 584          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 585          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 586          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 587          return RFAILED;
 588       }
 589    }
 590
 591    /*TransactionID*/
 592    idx = 0;
 593    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 594    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 595    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present = GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 596    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 597
 598    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 599
 600    /* Encode the F1SetupRequest type as UPER */
 601    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 602    encBufSize = 0;
 603    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 604
 605    /* Clean up */
 606    for(idx=0; idx<elementCnt; idx++)
 607    {
 608       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 609    }
 610    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 611    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 612    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 613
 614    /* Checking encode results */
 615    if(enRetVal.encoded == ENCODE_FAIL)
 616    {
 617       DU_LOG("\nF1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 618       return RFAILED;
 619    }
 620    else
 621    {
 622       DU_LOG("\nF1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 623       for(int i=0; i< encBufSize; i++)
 624       {
 625          printf("%x",encBuf[i]);
 626       }
 627    }
 628
 629    /* Sending msg */
 630    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 631    {
 632       DU_LOG("\nF1AP : Sending GNB-DU Config Update Ack failed");
 633       return RFAILED;
 634    }
 635
 636    return ROK;
 637
 638 }/* End of BuildAndSendDUUpdateAck*/
 639 /*******************************************************************
 640 *
 641 * @brief deallocating the memory of  F1reset msg
 642 *
 643 * @details
 644 *
 645 *    Function : FreeF1ResetReq
 646 *
 647 *    Functionality :
 648 *         - freeing memory of F1reset request msg
 649 *
 650 * @params[in]
 651 * @return void
 652 *
 653 *
 654 * ****************************************************************/
 655 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 656 {
 657     uint8_t idx = 0;
 658     Reset_t *f1ResetMsg = NULLP;
 659
 660     if(f1apMsg)
 661     {
 662        if(f1apMsg->choice.initiatingMessage)
 663        {
 664           f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 665           if(f1ResetMsg->protocolIEs.list.array)
 666           {
 667              for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 668              {
 669                  if(f1ResetMsg->protocolIEs.list.array[idx])
 670                  {
 671                     CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 672                  }
 673              }
 674              CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 675           }
 676           CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 677        }
 678        CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 679     }
 680 }
 681 /*******************************************************************
 682 *
 683 * @brief build ansld ans send f1reset msg
 684 *
 685 * @details
 686 *
 687 *    Function : BuildAndSendF1ResetReq
 688 *
 689 *    Functionality: build and send f1reset msg
 690 *
 691 * @return ROK     - success
 692 *         RFAILED - failure
 693 *
 694 * ****************************************************************/
 695 uint8_t BuildAndSendF1ResetReq()
 696 {
 697     uint8_t          elementCnt=0;
 698     uint8_t          idx=0;
 699     uint8_t          ret= RFAILED;
 700     Reset_t          *f1ResetMsg = NULLP;
 701     F1AP_PDU_t       *f1apMsg = NULLP;
 702     asn_enc_rval_t   encRetVal;
 703     DU_LOG("\nF1AP : Building F1 Reset request \n");
 704     do
 705     {
 706        CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 707        if(f1apMsg == NULLP)
 708        {
 709           DU_LOG("\nF1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 710           break;
 711        }
 712        f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 713        CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 714        if(f1apMsg->choice.initiatingMessage == NULLP)
 715        {
 716           DU_LOG("\nF1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 717           break;
 718        }
 719        f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 720        f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 721        f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 722
 723        f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 724
 725        elementCnt = 3;
 726        f1ResetMsg->protocolIEs.list.count = elementCnt;
 727        f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 728
 729        /* Initialize the F1Reset members */
 730        CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 731        if(f1ResetMsg->protocolIEs.list.array == NULLP)
 732        {
 733           DU_LOG("\nF1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 734           break;
 735        }
 736        for(idx=0; idx<elementCnt; idx++)
 737        {
 738            CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 739            if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 740            {
 741               DU_LOG("\nF1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 742               break;
 743            }
 744        }
 745
 746        /*TransactionID*/
 747        idx=0;
 748        f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 749        f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 750        f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 751        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 752
 753        /*Cause*/
 754        idx++;
 755        f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 756        f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 757        f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 758        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 759        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 760
 761        /*Reset Type*/
 762        idx++;
 763        f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 764        f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 765        f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 766        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 767        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 768
 769        xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 770
 771        /* Encode the F1SetupRequest type as APER */
 772        memset(encBuf, 0, ENC_BUF_MAX_LEN);
 773        encBufSize = 0;
 774        encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 775                    encBuf);
 776
 777        /* Encode results */
 778        if(encRetVal.encoded == ENCODE_FAIL)
 779        {
 780           DU_LOG("\nF1AP : Could not encode F1Reset structure (at %s)\n",\
 781                       encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 782           break;
 783        }
 784        else
 785        {
 786           DU_LOG("\nF1AP : Created APER encoded buffer for F1Reset\n");
 787           for(idx=0; idx< encBufSize; idx++)
 788           {
 789              printf("%x",encBuf[idx]);
 790           }
 791        }
 792
 793        if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 794        {
 795           DU_LOG("\nF1AP : Sending F1 Reset request failed");
 796           break;
 797        }
 798
 799        ret = ROK;
 800        break;
 801     }while(true);
 802
 803     FreeF1ResetReq(f1apMsg);
 804     return ret;
 805  }
 806
 807 /*******************************************************************
 808  *
 809  * @brief Fills Radio Bearer Config
 810  *
 811  * @details
 812  *
 813  *    Function : fillSrbCfg
 814  *
 815  *    Functionality: Fills Radio Bearer Config
 816  *
 817  * @params[in] SRB_ToAddModList *
 818  *
 819  * @return ROK     - success
 820  *         RFAILED - failure
 821  *
 822  * ****************************************************************/
 823 uint8_t fillSrbCfg(uint8_t srbId, SRB_ToAddModList_t *bearerCfg)
 824 {
 825    uint8_t elementCnt;
 826    uint8_t idx, ieId;
 827    if(bearerCfg != NULLP)
 828    {
 829       elementCnt = 1;
 830       bearerCfg->list.count = elementCnt;
 831       bearerCfg->list.size =\
 832            elementCnt * sizeof(SRB_ToAddMod_t *);
 833       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 834       if(bearerCfg->list.array != NULLP)
 835       {
 836          for(idx = 0; idx < elementCnt; idx++)
 837          {
 838             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 839             if(bearerCfg->list.array[idx] == NULLP)
 840             {
 841                for(ieId = 0; ieId < idx; ieId++)
 842                {
 843                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 844                }
 845                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 846                return RFAILED;
 847             }
 848          }
 849       }
 850       else
 851       {
 852          return RFAILED;
 853       }
 854       idx = 0;
 855       bearerCfg->list.array[idx]->srb_Identity = srbId;
 856    }
 857    return ROK;
 858 }
 859
 860 /*******************************************************************
 861  *
 862  * @brief Fills Master CellGroup Info
 863  *
 864  * @details
 865  *
 866  *    Function : fillMasterCellGroup
 867  *
 868  *    Functionality: Fills Master Cell Group IE
 869  *
 870  * @params[in] RRCSetup_IEs_t *
 871  *
 872  * @return ROK     - success
 873  *         RFAILED - failure
 874  *
 875  * ****************************************************************/
 876
 877 uint8_t fillMasterCellGroup(OCTET_STRING_t *masterCellGroup)
 878 {
 879    uint8_t ret = ROK;
 880    masterCellGroup->buf = NULLP;
 881    if(f1apMsgDb.duToCuContainer.buf)
 882    {
 883       masterCellGroup->size = f1apMsgDb.duToCuContainer.size;
 884       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 885       if(masterCellGroup->buf != NULLP)
 886       {
 887          memcpy(masterCellGroup->buf, f1apMsgDb.duToCuContainer.buf,\
 888                masterCellGroup->size);
 889       }
 890       else
 891       {
 892          ret = RFAILED;
 893       }
 894    }
 895    else
 896    {
 897       ret =  RFAILED;
 898    }
 899    return ret;
 900 }
 901
 902 /*******************************************************************
 903  *
 904  * @brief Fills RRC setup IE
 905  *
 906  * @details
 907  *
 908  *    Function : fillRRCSetupIE
 909  *
 910  *    Functionality: Fills RRC Setup IE
 911  *
 912  * @params[in] RRCSetup_IEs_t *
 913  *
 914  * @return ROK     - success
 915  *         RFAILED - failure
 916  *
 917  * ****************************************************************/
 918
 919 uint8_t fillRRCSetupIE(RRCSetup_IEs_t *rrcSetupIE)
 920 {
 921    uint8_t ret = ROK;
 922    if(rrcSetupIE)
 923    {
 924       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
 925       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
 926       {
 927          ret = fillSrbCfg(SRB1, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
 928       }
 929       if(ret == ROK)
 930       {
 931          ret = fillMasterCellGroup(&rrcSetupIE->masterCellGroup);
 932       }
 933       else
 934       {
 935          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
 936          ret = RFAILED;
 937       }
 938    }
 939    return ret;
 940 }
 941 /*******************************************************************
 942  *
 943  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
 944  *
 945  * @details
 946  *
 947  *    Function : fillDlCcchRrcMsg
 948  *
 949  *    Functionality: Fills DL DCCCH Message required for
 950  *                   DLRRCMessageTransfer
 951  *
 952  * @params[in] RRCContainer_t *rrcContainer
 953  *
 954  * @return ROK     - success
 955  *         RFAILED - failure
 956  *
 957  * ****************************************************************/
 958
 959 uint8_t fillDlCcchRrcMsg(RRCContainer_t *rrcContainer)
 960 {
 961    uint8_t ret = ROK;
 962    uint16_t idx2;
 963    DL_CCCH_Message_t dl_CCCH_Msg;
 964    asn_enc_rval_t        encRetVal;
 965
 966    if(rrcContainer != NULLP)
 967    {
 968       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
 969
 970       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
 971       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
 972       {
 973          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
 974          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
 975          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
 976          {
 977             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
 978             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
 979                present = RRCSetup__criticalExtensions_PR_rrcSetup;
 980             /* Fill RRC Setup IE */
 981             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 982                   criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
 983             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 984                   criticalExtensions.choice.rrcSetup != NULLP)
 985             {
 986                ret = fillRRCSetupIE(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 987                      criticalExtensions.choice.rrcSetup);
 988
 989                if(ret == ROK)
 990                {
 991                   /* encode DL-CCCH message into RRC Container */
 992                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
 993                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
 994                   encBufSize = 0;
 995                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
 996                   /* Encode results */
 997                   if(encRetVal.encoded == ENCODE_FAIL)
 998                   {
 999                      DU_LOG( "\n F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1000                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1001                      return RFAILED;
1002                   }
1003                   else
1004                   {
1005                      DU_LOG("\n F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1006                      for(int i = 0; i< encBufSize; i++)
1007                      {
1008                         printf("%x",encBuf[i]);
1009                      }
1010                      rrcContainer->size = encBufSize;
1011                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1012                      if(rrcContainer->buf != NULLP)
1013                      {
1014                         memset(rrcContainer->buf, 0, encBufSize);
1015                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1016                         {
1017                            rrcContainer->buf[idx2] =    encBuf[idx2];
1018                         }
1019                      }
1020                   }
1021                }
1022                else
1023                {
1024                   ret = RFAILED;
1025                }
1026             }
1027             else
1028             {
1029                DU_LOG("\nF1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1030                ret = RFAILED;
1031             }
1032          }
1033          else
1034          {
1035             DU_LOG("\nF1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1036             ret = RFAILED;
1037          }
1038       }
1039       else
1040       {
1041          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1042          ret = RFAILED;
1043       }
1044    }
1045    else
1046    {
1047       DU_LOG("\nF1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1048       ret = RFAILED;
1049    }
1050 }
1051
1052 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1053 {
1054    uint8_t idx, ied, elementCnt;
1055
1056    elementCnt = 1;
1057    qosFlow->list.count = elementCnt;
1058    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1059    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1060    if(qosFlow->list.array != NULLP)
1061    {
1062       for(idx = 0; idx < elementCnt; idx++)
1063       {
1064          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1065          if(qosFlow->list.array[idx] == NULLP)
1066          {
1067             for(ied = 0; ied < idx; ied++)
1068             {
1069                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1070             }
1071             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1072             return RFAILED;
1073          }
1074       }
1075    }
1076    idx = 0;
1077    *qosFlow->list.array[idx] = 9;
1078    return ROK;
1079 }
1080
1081 /*******************************************************************
1082  *
1083  * @brief Fills CN Assoc for Drb to Add/Mod List
1084  *
1085  * @details
1086  *
1087  *    Function : fillCnAssoc
1088  *
1089  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1090  *
1091  * @params[in] struct DRB_ToAddMod__cnAssociation *
1092  *
1093  * @return ROK     - success
1094  *         RFAILED - failure
1095  *
1096  * ****************************************************************/
1097
1098 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1099 {
1100    uint8_t ret = ROK;
1101
1102    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1103    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1104    {
1105       cnAssoc->choice.eps_BearerIdentity = 5;
1106    }
1107    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1108    {
1109       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1110       if(cnAssoc->choice.sdap_Config)
1111       {
1112          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1113          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1114          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1115          cnAssoc->choice.sdap_Config->defaultDRB = true;
1116          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1117          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1118          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1119             sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1120          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1121          {
1122             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1123          }
1124          else
1125          {
1126             DU_LOG("\nF1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1127             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1128             ret = RFAILED;
1129          }
1130       }
1131       else
1132       {
1133          DU_LOG("\nF1AP: Mem alloc failed at fillCnAssoc()");
1134          ret = RFAILED;
1135       }
1136    }
1137    return ret;
1138 }
1139
1140 /*******************************************************************
1141  *
1142  * @brief Fills Radio Bearer Config for Drb
1143  *
1144  * @details
1145  *
1146  *    Function : fillDrbCfg
1147  *
1148  *    Functionality: Fills Radio Bearer Config for Drb
1149  *
1150  * @params[in] drbId, DRB_ToAddModList *
1151  *
1152  * @return ROK     - success
1153  *         RFAILED - failure
1154  *
1155  * ****************************************************************/
1156 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1157 {
1158    uint8_t idx, ied, ret, elementCnt;
1159
1160    ret = ROK;
1161    if(drbCfg != NULLP)
1162    {
1163       elementCnt = 1;
1164       drbCfg->list.count = elementCnt;
1165       drbCfg->list.size =\
1166            elementCnt * sizeof(DRB_ToAddMod_t *);
1167       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1168       if(drbCfg->list.array != NULLP)
1169       {
1170          for(idx = 0; idx < elementCnt; idx++)
1171          {
1172             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1173             if(drbCfg->list.array[idx] == NULLP)
1174             {
1175                for(ied = 0; ied < idx; ied++)
1176                {
1177                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1178                }
1179                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1180                return RFAILED;
1181             }
1182          }
1183       }
1184       else
1185       {
1186          return RFAILED;
1187       }
1188       idx = 0;
1189       /* CN ASSOCIATION */
1190       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1191       if(drbCfg->list.array[idx]->cnAssociation)
1192       {
1193          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1194       }
1195       /* DRB */
1196       drbCfg->list.array[idx]->drb_Identity = drbId;
1197    }
1198    return ret;
1199 }
1200
1201 /*******************************************************************
1202  *
1203  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1204  *
1205  * @details
1206  *
1207  *    Function : fillRrcReconfigIE
1208  *
1209  *    Functionality: Fills RRC Reconfig Message required for
1210  *                   DLRRCMessageTransfer
1211  *
1212  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1213  *
1214  * @return ROK     - success
1215  *         RFAILED - failure
1216  *
1217  * ****************************************************************/
1218
1219 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1220 {
1221    uint8_t ret = ROK;
1222    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1223    if(rrcReconfigMsg->radioBearerConfig)
1224    {
1225       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1226       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1227       {
1228          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1229
1230       }
1231       if(ret == ROK)
1232       {
1233          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1234          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1235          {
1236             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1237             if(ret == RFAILED)
1238             {
1239                DU_LOG("\n F1AP: Failed to fill DrbCfg at fillRrcReconfigIE()");
1240                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1241                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1242             }
1243          }
1244       }
1245       else
1246       {
1247          DU_LOG("\n F1AP: memory Alloc failed at fillRrcReconfigIE()");
1248          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1249       }
1250    }
1251
1252    return ret;
1253 }
1254 /*******************************************************************
1255  *
1256  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1257  *
1258  * @details
1259  *
1260  *    Function : fillDlDcchRrcMsg
1261  *
1262  *    Functionality: Fills DL DCCH Message required for
1263  *                   DLRRCMessageTransfer
1264  *
1265  * @params[in] RRCContainer_t *rrcContainer
1266  *
1267  * @return ROK     - success
1268  *         RFAILED - failure
1269  *
1270  * ****************************************************************/
1271
1272 uint8_t fillDlDcchRrcMsg(RRCContainer_t *rrcContainer)
1273 {
1274    uint8_t ret = ROK;
1275    uint16_t idx2;
1276    DL_DCCH_Message_t dl_DCCH_Msg;
1277    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1278    asn_enc_rval_t        encRetVal;
1279
1280    if(rrcContainer != NULLP)
1281    {
1282       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1283
1284       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1285       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1286       {
1287          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1288          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1289          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1290          {
1291             dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->rrc_TransactionIdentifier = 0;
1292             dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->criticalExtensions.\
1293                present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
1294             /* Fill RRC Reconfig IE */
1295             CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1296                   criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
1297             if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1298                   criticalExtensions.choice.rrcReconfiguration != NULLP)
1299             {
1300                ret = fillRrcReconfigIE(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1301                      criticalExtensions.choice.rrcReconfiguration);
1302
1303                if(ret == ROK)
1304                {
1305                   /* encode DL-DCCH message into RRC Container */
1306                   xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1307                   cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
1308                   encBufSize = 0;
1309                   encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1310                   /* Encode results */
1311                   if(encRetVal.encoded == ENCODE_FAIL)
1312                   {
1313                      DU_LOG( "\n F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1314                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1315                      return RFAILED;
1316                   }
1317                   else
1318                   {
1319                      DU_LOG("\n F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1320                      for(int i = 0; i< encBufSize; i++)
1321                      {
1322                         printf("%x",encBuf[i]);
1323                      }
1324                      rrcContainer->size = encBufSize;
1325                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1326                      if(rrcContainer->buf != NULLP)
1327                      {
1328                         memset(rrcContainer->buf, 0, encBufSize);
1329                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1330                         {
1331                            rrcContainer->buf[idx2] =    encBuf[idx2];
1332                         }
1333                      }
1334                   }
1335                }
1336                else
1337                {
1338                   DU_LOG("\nF1AP: Failed to fill RrcReconfig IE at fillDlDcchRrcMsg()");
1339                }
1340             }
1341             else
1342             {
1343                DU_LOG("\nF1AP: Memory Alloc failed for RRC Reconfig at fillDlDcchRrcMsg()");
1344                ret = RFAILED;
1345             }
1346          }
1347          else
1348          {
1349             DU_LOG("\nF1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1350             ret = RFAILED;
1351          }
1352       }
1353       else
1354       {
1355          DU_LOG("\nF1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1356          ret = RFAILED;
1357       }
1358    }
1359    else
1360    {
1361       DU_LOG("\nF1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1362       ret = RFAILED;
1363    }
1364    return ret;
1365 }
1366
1367 /*******************************************************************
1368  *
1369  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1370  *
1371  * @details
1372  *
1373  *    Function : BuildDLRRCContainer
1374  *
1375  *    Functionality: Builds RRC Container IE required for
1376  *                   DLRRCMessageTransfer
1377  *
1378  * @params[in]
1379  *
1380  * @return ROK     - success
1381  *         RFAILED - failure
1382  *
1383  * ****************************************************************/
1384
1385 uint8_t BuildDLRRCContainer(uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1386 {
1387    uint8_t ret = ROK;
1388
1389    if(rrcMsgType == RRC_SETUP)
1390    {
1391       ret = fillDlCcchRrcMsg(rrcContainer);
1392       if(ret == RFAILED)
1393          DU_LOG("\n F1AP: Failed to fill DL-CCCH Msg at BuildDLRRCContainer()");
1394    }
1395    else if(rrcMsgType == RRC_RECONFIG)
1396    {
1397       ret = fillDlDcchRrcMsg(rrcContainer);
1398       if(ret == RFAILED)
1399          DU_LOG("\n F1AP: Failed at fill DL-DCCH Msg at BuildDLRRCContainer()");
1400    }
1401    return ret;
1402 }
1403
1404 /*******************************************************************
1405  *
1406  * @brief Builds and sends the DLRRCMessageTransfer
1407  *
1408  * @details
1409  *
1410  *    Function : BuildAndSendDLRRCMessageTransfer
1411  *
1412  *    Functionality: Constructs the DL RRC Message Transfer and sends
1413  *                   it to the CU through SCTP.
1414  *
1415  * @params[in]
1416  *
1417  * @return ROK     - success
1418  *         RFAILED - failure
1419  *
1420  * ****************************************************************/
1421 uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t rrcMsgType)
1422 {
1423    uint8_t   elementCnt = 0;
1424    uint8_t  ieId;
1425    uint8_t  idx;
1426    F1AP_PDU_t  *f1apMsg = NULLP;
1427    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1428    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1429
1430    DU_LOG("\n F1AP : Building DL RRC Message Transfer Message\n");
1431
1432    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1433    if(f1apMsg == NULLP)
1434    {
1435       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1436       return RFAILED;
1437    }
1438
1439    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1440    CU_ALLOC(f1apMsg->choice.initiatingMessage,
1441          sizeof(InitiatingMessage_t));
1442    if(f1apMsg->choice.initiatingMessage == NULLP)
1443    {
1444       DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
1445       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1446       return RFAILED;
1447    }
1448
1449    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1450    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1451    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1452    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1453
1454    elementCnt = 4;
1455    dlRRCMsg->protocolIEs.list.count = elementCnt;
1456    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1457
1458    /* Initialize the F1Setup members */
1459    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1460    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1461    {
1462       DU_LOG(" F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1463       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1464       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1465       return RFAILED;
1466    }
1467
1468    for(idx=0; idx<elementCnt; idx++)
1469    {
1470       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1471       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1472       {
1473          for(ieId=0; ieId<idx; ieId++)
1474          {
1475             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId],\
1476                   sizeof(DLRRCMessageTransferIEs_t));
1477          }
1478          CU_FREE(dlRRCMsg->protocolIEs.list.array,\
1479                dlRRCMsg->protocolIEs.list.size);
1480          CU_FREE(f1apMsg->choice.initiatingMessage,\
1481                sizeof(InitiatingMessage_t));
1482          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1483          return RFAILED;
1484       }
1485    }
1486
1487    /* GNB CU UE F1AP ID */
1488    idx = 0;
1489    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1490    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1491    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1492                                                           DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1493    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
1494
1495    /* GNB DU UE F1AP ID */
1496    idx++;
1497    dlRRCMsg->protocolIEs.list.array[idx]->id  = \
1498                                                 ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1499    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1500    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1501                                                           DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1502    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
1503
1504    /* SRBID */
1505    idx++;
1506    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1507    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1508    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1509                                                           DLRRCMessageTransferIEs__value_PR_SRBID;
1510    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = SRB1;
1511
1512    /* RRCContainer */
1513    idx++;
1514    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1515    dlRRCMsg->protocolIEs.list.array[idx]->criticality   = Criticality_reject;
1516    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1517                                                           DLRRCMessageTransferIEs__value_PR_RRCContainer;
1518    BuildDLRRCContainer(rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1519
1520    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1521
1522    /* Encode the F1SetupRequest type as APER */
1523    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1524    encBufSize = 0;
1525    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1526          encBuf);
1527    /* Encode results */
1528    if(encRetVal.encoded == ENCODE_FAIL)
1529    {
1530       DU_LOG( "\n F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1531             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1532       return RFAILED;
1533    }
1534    else
1535    {
1536       DU_LOG("\n F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1537       for(int i=0; i< encBufSize; i++)
1538       {
1539          printf("%x",encBuf[i]);
1540       }
1541    }
1542
1543    /* Sending  msg  */
1544    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=  ROK)
1545    {
1546       DU_LOG("\n F1AP : Sending  DL RRC Message Transfer Failed");
1547       return RFAILED;
1548    }
1549
1550    return ROK;
1551 }/* End of BuildAndSendDLRRCMessageTransfer */
1552
1553 /*******************************************************************
1554  *
1555  * @brief Builds and sends the UE Setup Response
1556  *
1557  * @details
1558  *
1559  *    Function : BuildAndSendUESetRsp
1560  *
1561  *    Functionality: Constructs the UE Setup Response and sends
1562  *                   it to the DU through SCTP.
1563  *
1564  * @params[in]
1565  *
1566  * @return ROK     - success
1567  *         RFAILED - failure
1568  *
1569  * ****************************************************************/
1570 S16 BuildAndSendUESetRsp()
1571 {
1572    S16  ret;
1573    U8   elementCnt;
1574    U8   cellCnt;
1575    U8   ieId;
1576    U8   idx;
1577    U8   drbCnt;
1578    U8   drbId;
1579    F1AP_PDU_t                                                   *f1apMsg = NULL;
1580    UEContextSetupResponse_t                     *ueSetRsp;
1581    asn_enc_rval_t                                               encRetVal;        /* Encoder return value */
1582
1583    DU_LOG("\n F1AP : Building UE Context Setup Response\n");
1584
1585    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1586    if(f1apMsg == NULLP)
1587    {
1588       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1589       return RFAILED;
1590    }
1591
1592    f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
1593    CU_ALLOC(f1apMsg->choice.successfulOutcome,
1594          sizeof(SuccessfulOutcome_t));
1595    if(f1apMsg->choice.successfulOutcome == NULLP)
1596    {
1597       DU_LOG(" F1AP : Memory allocation for     F1AP-PDU failed");
1598       CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1599       return RFAILED;
1600    }
1601
1602    f1apMsg->choice.successfulOutcome->procedureCode = \
1603                                                       ProcedureCode_id_UEContextSetup;
1604    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
1605    f1apMsg->choice.successfulOutcome->value.present = \
1606                                                       SuccessfulOutcome__value_PR_UEContextSetupResponse;
1607    ueSetRsp =
1608       &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
1609    elementCnt = 2;
1610    ueSetRsp->protocolIEs.list.count = elementCnt;
1611    ueSetRsp->protocolIEs.list.size = \
1612                                      elementCnt * sizeof(UEContextSetupResponse_t *);
1613
1614    /* Initialize the UESetup members */
1615    CU_ALLOC(ueSetRsp->protocolIEs.list.array, \
1616          ueSetRsp->protocolIEs.list.size);
1617    if(ueSetRsp->protocolIEs.list.array == NULLP)
1618    {
1619       DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
1620       CU_FREE(f1apMsg->choice.successfulOutcome,
1621             sizeof(SuccessfulOutcome_t));
1622       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
1623       return RFAILED;
1624    }
1625
1626    for(idx=0; idx<elementCnt; idx++)
1627    {
1628       CU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
1629             sizeof(UEContextSetupResponseIEs_t));
1630       if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
1631       {
1632          for(ieId=0; ieId<idx; ieId++)
1633          {
1634             CU_FREE(ueSetRsp->protocolIEs.list.array[ieId],\
1635                   sizeof(UEContextSetupResponseIEs_t));
1636          }
1637          CU_FREE(ueSetRsp->protocolIEs.list.array,\
1638                ueSetRsp->protocolIEs.list.size);
1639          CU_FREE(f1apMsg->choice.successfulOutcome,\
1640                sizeof(SuccessfulOutcome_t));
1641          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1642          return RFAILED;
1643       }
1644    }
1645
1646    idx = 0;
1647
1648    /*GNB CU UE F1AP ID*/
1649    ueSetRsp->protocolIEs.list.array[idx]->id    = \
1650                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1651    ueSetRsp->protocolIEs.list.array[idx]->criticality   =       Criticality_reject;
1652    ueSetRsp->protocolIEs.list.array[idx]->value.present = \
1653                                                           UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
1654    ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
1655
1656    /*GNB DU UE F1AP ID*/
1657    idx++;
1658    ueSetRsp->protocolIEs.list.array[idx]->id    = \
1659                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1660    ueSetRsp->protocolIEs.list.array[idx]->criticality   =       Criticality_reject;
1661    ueSetRsp->protocolIEs.list.array[idx]->value.present = \
1662                                                           UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
1663    ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
1664
1665
1666    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1667
1668    /* Encode the F1SetupRequest type as APER */
1669    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1670    encBufSize = 0;
1671    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1672          encBuf);
1673    /* Encode results */
1674    if(encRetVal.encoded == ENCODE_FAIL)
1675    {
1676       DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
1677             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1678       return RFAILED;
1679    }
1680    else
1681    {
1682       DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
1683       for(int i=0; i< encBufSize; i++)
1684       {
1685          printf("%x",encBuf[i]);
1686       }
1687    }
1688
1689    /* Sending  msg  */
1690    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)       !=      ROK)
1691    {
1692       DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
1693       return RFAILED;
1694    }
1695
1696    return ROK;
1697 }/* End of BuildAndSendUESetRsp */
1698
1699 /*******************************************************************
1700  *
1701  * @brief Function to set the Dl RRC Msg Type
1702  *
1703  * @details
1704  *
1705  *    Function : setDlRRCMsgType
1706  *
1707  *    Functionality: Constructs the UE Setup Response and sends
1708  *                   it to the DU through SCTP.
1709  *
1710  * @params[in]
1711  *
1712  * @return ROK     - success
1713  *         RFAILED - failure
1714  *
1715  * ****************************************************************/
1716
1717 uint8_t setDlRRCMsgType()
1718 {
1719    uint8_t rrcMsgType = 0;
1720    switch(f1apMsgDb.dlRrcMsgCount)
1721    {
1722       case RRC_SETUP:
1723         rrcMsgType = RRC_SETUP;
1724         break;
1725       case RRC_SECURITY_MODE_COMMAND:
1726         rrcMsgType = RRC_SECURITY_MODE_COMMAND;
1727         break;
1728       case RRC_RECONFIG:
1729         rrcMsgType = RRC_RECONFIG;
1730         break;
1731       default:
1732         break;
1733    }
1734    return rrcMsgType;
1735 }
1736
1737 /*******************************************************************
1738  *
1739  * @brief Function to build Initial UL RRC Message
1740  *
1741  * @details
1742  *
1743  *    Function : procInitULRRCMsg
1744  *
1745  *    Functionality: Function to build Initial UL RRC Message
1746  *
1747  * @params[in]
1748  *
1749  * @return ROK     - success
1750  *         RFAILED - failure
1751  *
1752  * ****************************************************************/
1753
1754 uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
1755 {
1756    uint8_t idx, rrcMsgType;
1757    uint8_t ret =ROK;
1758    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1759    DU_LOG("\n filling the required values in DB in procInitULRRCMsg");
1760
1761    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1762
1763    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
1764    {
1765       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
1766       {
1767          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
1768             break;
1769          case ProtocolIE_ID_id_NRCGI:
1770             break;
1771          case ProtocolIE_ID_id_C_RNTI:
1772             break;
1773          case ProtocolIE_ID_id_RRCContainer:
1774             break;
1775          case ProtocolIE_ID_id_DUtoCURRCContainer:
1776             {
1777                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
1778                         .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
1779                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
1780                {
1781                   DU_LOG("\n Received Du to Cu RRC Container ");
1782                   f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
1783                                                    .list.array[idx]->value.choice.DUtoCURRCContainer.size;
1784                   CU_ALLOC(f1apMsgDb.duToCuContainer.buf, \
1785                         f1apMsgDb.duToCuContainer.size);
1786                   if(f1apMsgDb.duToCuContainer.buf != NULLP)
1787                   {
1788                      memcpy(f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
1789                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf, f1apMsgDb\
1790                            .duToCuContainer.size);
1791                   }
1792                }
1793                else
1794                {
1795                   DU_LOG("\n Failed to receive Du to Cu RRC Container ");
1796                   ret = RFAILED;
1797                }
1798                break;
1799             }
1800          default:
1801             DU_LOG("\n Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
1802             break;
1803       }
1804    }
1805    if(ret == ROK)
1806    {
1807       f1apMsgDb.dlRrcMsgCount++;
1808       rrcMsgType = setDlRRCMsgType();
1809       ret = BuildAndSendDLRRCMessageTransfer(rrcMsgType);
1810    }
1811    return ret;
1812 }
1813
1814 /*******************************************************************
1815  *
1816  * @brief Builds Nrcgi
1817  *
1818  * @details
1819  *
1820  *    Function : BuildNrcgi
1821  *
1822  *    Functionality: Building the PLMN ID and NR Cell id
1823  *
1824  * @params[in] NRCGI_t *nrcgi
1825  * @return ROK     - success
1826  *         RFAILED - failure
1827  *
1828  * ****************************************************************/
1829 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
1830 {
1831    uint8_t ret;
1832    uint8_t unused = 4;
1833    uint8_t byteSize = 5;
1834    uint8_t val = 16;
1835    /* Allocate Buffer Memory */
1836    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
1837    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1838    if(nrcgi->pLMN_Identity.buf == NULLP)
1839    {
1840       return RFAILED;
1841    }
1842    ret = buildPlmnId(cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
1843
1844    if(ret != ROK)
1845    {
1846       return RFAILED;
1847    }
1848    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
1849    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1850    if(nrcgi->nRCellIdentity.buf == NULLP)
1851    {
1852       return RFAILED;
1853    }
1854    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
1855    if(ret != ROK)
1856    {
1857       return RFAILED;
1858    }
1859    return ROK;
1860 }
1861 /*******************************************************************
1862  *
1863  * @brief Builds Special cell list for UE Setup Request
1864  *
1865  * @details
1866  *
1867  *    Function : BuildSplCellList
1868  *
1869  *    Functionality: Constructs the Special Cell list for UESetReq
1870  *
1871  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1872  *
1873  * @return ROK     - success
1874  *         RFAILED - failure
1875  *
1876  * ****************************************************************/
1877 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1878 {
1879    uint8_t  cellCnt;
1880    uint8_t  idx;
1881    uint8_t  ret;
1882    cellCnt = 1;
1883    spCellLst->list.count = cellCnt;
1884    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
1885    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
1886    if(spCellLst->list.array == NULLP)
1887    {
1888       return RFAILED;
1889    }
1890    for(idx=0; idx<cellCnt; idx++)
1891    {
1892       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1893       if(spCellLst->list.array[idx] == NULLP)
1894       {
1895          return RFAILED;
1896       }
1897    }
1898    idx = 0;
1899    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
1900    spCellLst->list.array[idx]->criticality = Criticality_ignore;
1901    spCellLst->list.array[idx]->value.present =\
1902                                               SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
1903    /* Special Cell ID -NRCGI */
1904    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1905    if(ret != ROK)
1906    {
1907       return RFAILED;
1908    }
1909    /*Special Cell Index*/
1910    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
1911    return ROK;
1912 }/* End of BuildSplCellList*/
1913
1914 /*******************************************************************
1915  *
1916  * @brief Builds SRBS to be setup
1917  *
1918  * @details
1919  *
1920  *    Function : BuildSRBSetup
1921  *
1922  *    Functionality: Constructs the SRB's for UESetReq
1923  *
1924  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1925  *
1926  * @return ROK     - success
1927  *         RFAILED - failure
1928  *
1929  * ****************************************************************/
1930 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1931 {
1932    uint8_t idx;
1933    uint8_t srbCnt;
1934    srbCnt = 1;
1935    srbSet->list.count = srbCnt;
1936    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
1937    CU_ALLOC(srbSet->list.array,srbSet->list.size);
1938    if(srbSet->list.array == NULLP)
1939    {
1940       return RFAILED;
1941    }
1942    for(idx=0; idx<srbCnt; idx++)
1943    {
1944       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1945       if(srbSet->list.array[idx] == NULLP)
1946       {
1947          return RFAILED;
1948       }
1949    }
1950    idx = 0;
1951    srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
1952    srbSet->list.array[idx]->criticality = Criticality_ignore;
1953    srbSet->list.array[idx]->value.present = \
1954       SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
1955    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
1956    return ROK;
1957 }/* End of BuildSRBSetup*/
1958
1959 /*******************************************************************
1960  *
1961  * @brief Builds QOS Info for DRB Setum Item
1962  *
1963  * @details
1964  *
1965  *    Function : BuildQOSInfo
1966  *
1967  *    Functionality: Constructs the QOS Info for DRB Setup Item
1968  *
1969  * @params[in] QoSInformation_t *qosinfo
1970  *
1971  * @return ROK     - success
1972  *         RFAILED - failure
1973  *
1974  * ****************************************************************/
1975 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
1976 {
1977    /* NonDynamic5QIDescriptor */
1978    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
1979    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
1980    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
1981    {
1982       return RFAILED;
1983    }
1984    /*FiveQI*/
1985    drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
1986    /*AveragingWindow*/
1987    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
1988          sizeof(AveragingWindow_t));
1989    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
1990          NULLP)
1991    {
1992       return RFAILED;
1993    }
1994    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
1995    /*MaxDataBurstVolume*/
1996    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
1997          sizeof(MaxDataBurstVolume_t));
1998    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
1999          NULLP)
2000    {
2001       return RFAILED;
2002    }
2003    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2004
2005    /*nRGRAN Allocation Retention Priority*/
2006    drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_highest;
2007    drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2008    drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2009
2010    /* TO DO: GBR_QoSFlowInformation */
2011    return ROK;
2012 }/*End of BuildQOSInfo*/
2013
2014 /*******************************************************************
2015  *
2016  * @brief Builds SNSSAI
2017  *
2018  * @details
2019  *
2020  *    Function : BuildSNSSAI
2021  *
2022  *    Functionality: Constructs the SNSSAI For DRB list
2023  *
2024  * @params[in] SNSSAI_t *snssai
2025  *
2026  * @return ROK     - success
2027  *         RFAILED - failure
2028  *
2029  * ****************************************************************/
2030 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
2031 {
2032    /*SNSSAI*/
2033    /*ssT*/
2034    snssai->sST.size = sizeof(uint8_t);
2035    CU_ALLOC(snssai->sST.buf,snssai->sST.size);
2036    if(snssai->sST.buf == NULLP)
2037    {
2038       return RFAILED;
2039    }
2040    snssai->sST.buf[0] = 3;
2041    /*sD*/
2042    CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
2043    if(snssai->sD == NULLP)
2044    {
2045       return RFAILED;
2046    }
2047    snssai->sD->size = 3*sizeof(uint8_t);
2048    CU_ALLOC(snssai->sD->buf,snssai->sD->size);
2049    if(snssai->sD->buf == NULLP)
2050    {
2051       return RFAILED;
2052    }
2053    snssai->sD->buf[0] = 3;
2054    snssai->sD->buf[1] = 6;
2055    snssai->sD->buf[2] = 9;
2056    return ROK;
2057 }/*End of BuildSNSSAI*/
2058
2059 /*******************************************************************
2060  *
2061  * @brief Builds the flow map.
2062  *
2063  * @details
2064  *
2065  *    Function : BuildFlowsMap
2066  *
2067  *    Functionality: Constructs the flowmap For DRB list
2068  *
2069  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2070  *
2071  * @return ROK     - success
2072  *         RFAILED - failure
2073  *
2074  * ****************************************************************/
2075 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
2076 {
2077    uint8_t  ret;
2078    uint8_t  idx;
2079    uint8_t  flowCnt;
2080    flowCnt = 1;
2081    flowMap->list.count = flowCnt;
2082    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2083    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2084    if(flowMap->list.array == NULLP)
2085    {
2086       return RFAILED;
2087    }
2088    for(idx=0; idx<flowCnt; idx++)
2089    {
2090       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2091       if(flowMap->list.array[idx] == NULLP)
2092       {
2093          return RFAILED;
2094       }
2095    }
2096    idx = 0;
2097    flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2098    ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
2099    if(ret != ROK)
2100    {
2101       return RFAILED;
2102    }
2103    return ROK;
2104 }/*End of BuildFlowsMap*/
2105
2106 /*******************************************************************
2107  *
2108  * @brief Builds the Uplink Tunnel Info
2109  *
2110  * @details
2111  *
2112  *    Function : BuildULTnlInfo
2113  *
2114  *    Functionality: Constructs the UL TnlInfo For DRB list
2115  *
2116  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2117  *
2118  * @return ROK     - success
2119  *         RFAILED - failure
2120  *
2121  * ****************************************************************/
2122 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2123 {
2124    uint8_t idx;
2125    uint8_t ulCnt;
2126    ulCnt = 1;
2127    ulInfo->list.count = ulCnt;
2128    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2129    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2130    if(ulInfo->list.array == NULLP)
2131    {
2132       return RFAILED;
2133    }
2134    for(idx=0; idx<ulCnt; idx++)
2135    {
2136       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2137       if(ulInfo->list.array[idx] == NULLP)
2138       {
2139          return RFAILED;
2140       }
2141    }
2142    idx = 0;
2143    ulInfo->list.array[idx]->uLUPTNLInformation.present = \
2144                                                          UPTransportLayerInformation_PR_gTPTunnel;
2145    /*GTP TUNNEL*/
2146    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
2147          sizeof(GTPTunnel_t));
2148    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2149    {
2150       return RFAILED;
2151    }
2152    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2153       transportLayerAddress.size        = 4*sizeof(uint8_t);
2154    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2155          transportLayerAddress.buf,ulInfo->list.array[idx]->\
2156          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2157    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2158          transportLayerAddress.buf == NULLP)
2159    {
2160       return RFAILED;
2161    }
2162    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2163       transportLayerAddress.buf[0] = 4;
2164    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2165       transportLayerAddress.buf[1] = 4;
2166    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2167       transportLayerAddress.buf[2] = 4;
2168    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2169       transportLayerAddress.buf[3] = 5;
2170    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2171       transportLayerAddress.bits_unused = 0;
2172    /*GTP TEID*/
2173    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
2174       = 4 * sizeof(uint8_t);
2175    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2176          gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
2177          gTPTunnel->gTP_TEID.size);
2178    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2179          == NULLP)
2180    {
2181       return RFAILED;
2182    }
2183    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2184       gTP_TEID.buf[0] = 11;
2185    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2186       gTP_TEID.buf[1] = 0;
2187    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2188       gTP_TEID.buf[2] = 0;
2189    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2190       gTP_TEID.buf[3] = 1;
2191
2192    return ROK;
2193 }/*End of BuildULTnlInfo*/
2194
2195 /*******************************************************************
2196  *
2197  * @brief Builds DRBS to be setup
2198  *
2199  * @details
2200  *
2201  *    Function : BuildDRBSetup
2202  *
2203  *    Functionality: Constructs the DRB's for UESetReq
2204  *
2205  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2206  *
2207  * @return ROK     - success
2208  *         RFAILED - failure
2209  *
2210  * ****************************************************************/
2211 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2212 {
2213    uint8_t BuildQOSInforet;
2214    uint8_t BuildSNSSAIret;
2215    uint8_t BuildFlowsMapret;
2216    uint8_t BuildULTnlInforet;
2217    uint8_t idx;
2218    uint8_t drbCnt;
2219    DRBs_ToBeSetup_Item_t *drbSetItem;
2220    drbCnt = 1;
2221    drbSet->list.count = drbCnt;
2222    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2223    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2224    if(drbSet->list.array == NULLP)
2225    {
2226       return RFAILED;
2227    }
2228    for(idx=0; idx<drbCnt; idx++)
2229    {
2230       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2231       if(drbSet->list.array[idx] == NULLP)
2232       {
2233          return RFAILED;
2234       }
2235    }
2236    idx = 0;
2237    drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2238    drbSet->list.array[idx]->criticality = Criticality_ignore;
2239    drbSet->list.array[idx]->value.present = \
2240                                             DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2241    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2242    /*dRBID*/
2243    drbSetItem->dRBID = 1;
2244    /*qoSInformation*/
2245    drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2246    CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2247    if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2248    {
2249       return RFAILED;
2250    }
2251    drbSetItem->qoSInformation.choice.choice_extension->id = \
2252                                                             ProtocolIE_ID_id_DRB_Information;
2253    drbSetItem->qoSInformation.choice.choice_extension->criticality = \
2254                                                                      Criticality_ignore;
2255    drbSetItem->qoSInformation.choice.choice_extension->value.present = \
2256                                                                        QoSInformation_ExtIEs__value_PR_DRB_Information;
2257   BuildQOSInforet =  BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
2258          choice_extension->value.choice.DRB_Information.dRB_QoS);
2259    if(BuildQOSInforet != ROK)
2260    {
2261       return RFAILED;
2262    }
2263    /*SNSSAI*/
2264    BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
2265          choice_extension->value.choice.DRB_Information.sNSSAI);
2266    if(BuildSNSSAIret != ROK)
2267    {
2268       return RFAILED;
2269    }
2270    /*Flows mapped to DRB List*/
2271    BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
2272          choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
2273    if(BuildFlowsMapret != ROK)
2274    {
2275       return RFAILED;
2276    }
2277    /*ULUPTNLInformation To Be Setup List*/
2278    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2279    if(BuildULTnlInforet != ROK)
2280    {
2281       return RFAILED;
2282    }
2283    /*RLCMode*/
2284    drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2285
2286    /*UL Configuration*/
2287    CU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2288    if(drbSetItem->uLConfiguration == NULLP)
2289    {
2290       return RFAILED;
2291    }
2292    drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
2293    return ROK;
2294 }/* End of BuildDRBSetup*/
2295
2296 /*******************************************************************
2297  *
2298  * @brief Deallocating memory of function BuildAndSendUESetReq
2299  *
2300  * @details
2301  *
2302  *    Function : FreeNrcgi
2303  *
2304  *    Functionality: Deallocating memory for function BuildNrcgi
2305  *
2306  * @params[in] NRCGI_t *nrcgi
2307  *
2308  * @return void
2309  *
2310  *******************************************************************/
2311 void FreeNrcgi(NRCGI_t *nrcgi)
2312 {
2313    if(nrcgi->pLMN_Identity.buf != NULLP)
2314    {
2315       if(nrcgi->nRCellIdentity.buf != NULLP)
2316       {
2317          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2318       }
2319       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2320    }
2321 }
2322 /*******************************************************************
2323  *
2324  * @brief  Deallocating memory of function BuildAndSendUESetReq
2325  *
2326  * @details
2327  *
2328  *    Function : FreeSplCellList
2329  *
2330  *    Functionality: Deallocating memory for function BuildSplCellList
2331  *
2332  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2333  *
2334  * @return void
2335  *
2336  *
2337  * *****************************************************************/
2338 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2339 {
2340    uint8_t  cellidx;
2341    if(spCellLst->list.array != NULLP)
2342    {
2343       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2344       {
2345          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2346          {
2347             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2348          }
2349          if(spCellLst->list.array[cellidx]!=NULLP)
2350          {
2351             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2352          }
2353       }
2354       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2355    }
2356 }
2357 /*******************************************************************
2358  *
2359  * @brief Deallocating memory of function BuildAndSendUESetReq
2360  *
2361  * @details
2362  *
2363  *    Function : FreeSRBSetup
2364  *
2365  *    Functionality: Deallocating memory for function BuildSRBSetup
2366  *
2367  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2368  *
2369  * @return void
2370  *
2371  *
2372  * ******************************************************************/
2373 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2374 {
2375    uint8_t srbidx;
2376    if(srbSet->list.array != NULLP)
2377    {
2378       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2379       {
2380          if(srbSet->list.array[srbidx]!=NULLP)
2381          {
2382             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2383          }
2384       }
2385       CU_FREE(srbSet->list.array,srbSet->list.size);
2386    }
2387 }
2388 /*******************************************************************
2389  *
2390  * @brief Deallocating memory of function BuildAndSendUESetReq
2391  *
2392  * @details
2393  *
2394  *    Function : FreeQOSInfo
2395  *
2396  *    Functionality:  Deallocating memory for function BuildQOSInfo
2397  *
2398  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2399  *
2400  * @return void
2401  *
2402  * ****************************************************************/
2403 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2404 {
2405    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2406    {
2407       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2408       {
2409          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2410          {
2411             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2412                   sizeof(MaxDataBurstVolume_t));
2413          }
2414          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2415                sizeof(AveragingWindow_t));
2416       }
2417       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2418             sizeof(NonDynamic5QIDescriptor_t));
2419    }
2420 }
2421 /*******************************************************************
2422  *
2423  * @brief Deallocating memory of function BuildAndSendUESetReq
2424  *
2425  * @details
2426  *
2427  *    Function : FreeULTnlInfo
2428  *
2429  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2430  *
2431  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2432  *
2433  * @return void
2434  *
2435
2436  * ****************************************************************/
2437 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2438 {
2439    uint8_t ulidx=0;
2440    if(ulInfo->list.array != NULLP)
2441    {
2442       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2443       {
2444          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2445          {
2446             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2447             {
2448                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2449                      transportLayerAddress.buf != NULLP)
2450                {
2451                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2452                         !=NULLP)
2453                   {
2454                      CU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2455                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2456                            gTPTunnel->gTP_TEID.size);
2457                   }
2458                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2459                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2460                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2461                }
2462                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2463                      sizeof(GTPTunnel_t));
2464             }
2465          }
2466          if(ulInfo->list.array[ulidx]!=NULLP)
2467          {
2468             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2469          }
2470       }
2471       CU_FREE(ulInfo->list.array,ulInfo->list.size);
2472    }
2473 }
2474 /*******************************************************************
2475  *
2476  * @brief Deallocating memory for BuildAndSendUESetReq
2477  *
2478  * @details
2479  *
2480  *    Function : FreeDRBSetup
2481  *
2482  *    Functionality:  Deallocating memory for BuildDRBSetup
2483  *
2484  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2485  *
2486  * @return void
2487  *
2488  * ****************************************************************/
2489 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2490 {
2491    DRBs_ToBeSetup_Item_t *drbSetItem;
2492    uint8_t  flowidx;
2493    uint8_t  drbidx;
2494    if(drbSet->list.array == NULLP)
2495    {
2496       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
2497       {
2498          if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
2499          {
2500             drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
2501             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
2502             {
2503                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2504                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
2505                {
2506                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2507                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2508                   {
2509                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2510                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2511                      {
2512                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
2513                         {
2514                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
2515                            {
2516                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
2517                               {
2518                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2519                                        flows_Mapped_To_DRB_List.list.array != NULLP)
2520                                  {
2521                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2522                                           flows_Mapped_To_DRB_List.list.count; flowidx++)
2523                                     {
2524                                        if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2525                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2526                                        {
2527                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2528                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2529                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
2530                                           {
2531                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2532                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2533                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2534                                              {
2535                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2536                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2537                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2538                                                 {
2539                                                    FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2540                                                    CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2541
2542                                                    CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2543                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2544                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2545                                                          sizeof(MaxDataBurstVolume_t));
2546                                                 }
2547                                                 CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2548                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2549                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2550                                              }
2551                                              CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2552                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2553                                                    qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2554                                           }
2555                                        }
2556                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2557                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2558                                        {
2559                                           CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2560                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
2561                                        }
2562                                     }
2563                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2564                                           flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
2565                                           choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
2566                                  }
2567                                  CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
2568                                        drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
2569                               }
2570                               CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
2571                                     sizeof(OCTET_STRING_t));
2572                            }
2573                            CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
2574                                  drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
2575                         }
2576                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2577                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
2578                      }
2579                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2580                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2581                   }
2582                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2583                         qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
2584                }
2585                CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2586             }
2587          }
2588          if(drbSet->list.array[drbidx]!=NULLP)
2589          {
2590             CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2591          }
2592       }
2593       CU_FREE(drbSet->list.array,drbSet->list.size);
2594    }
2595 }
2596
2597
2598 /*******************************************************************
2599  *
2600  * @brief Free the UE Setup Request
2601  *
2602  * @details
2603  *
2604  *    Function : FreeUESetReq
2605  *
2606  *    Functionality: Deallocate the memory of BuildUESetReq
2607  *
2608  * @params[in]  F1AP_PDU_t  *f1apMsg
2609  *
2610  * @return void
2611  *
2612  *
2613  * ****************************************************************/
2614 void FreeUESetReq(F1AP_PDU_t  *f1apMsg)
2615 {
2616    uint8_t idx=2;
2617    uint8_t ieId;
2618    UEContextSetupRequest_t       *ueSetReq;
2619
2620    if(f1apMsg != NULLP)
2621    {
2622       if(f1apMsg->choice.initiatingMessage != NULLP)
2623       {
2624          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2625          if(ueSetReq->protocolIEs.list.array != NULLP)
2626          {
2627             if(ueSetReq->protocolIEs.list.array[idx])
2628             {
2629                FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2630                idx=6;
2631                if(ueSetReq->protocolIEs.list.array[idx])
2632                {
2633                   FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2634                   idx++;
2635                   if(ueSetReq->protocolIEs.list.array[idx])
2636                   {
2637                      FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2638                      idx++;
2639                      if(ueSetReq->protocolIEs.list.array[idx])
2640                      {
2641                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2642                      }
2643                   }
2644                }
2645             }
2646             for(ieId=0; ieId<ueSetReq->protocolIEs.list.count; ieId++)
2647             {
2648                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
2649                {
2650                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
2651                }
2652             }
2653             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2654          }
2655          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2656       }
2657       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2658    }
2659 }
2660
2661 /*******************************************************************
2662  *
2663  * @brief Builds and sends the UE Setup Request
2664  *
2665  * @details
2666  *
2667  *    Function : BuildAndSendUESetReq
2668  *
2669  *    Functionality: Constructs the UE Setup Request and sends
2670  *                   it to the CU through SCTP.
2671  *
2672  * @params[in]
2673  *
2674  * @return ROK     - success
2675  *         RFAILED - failure
2676  *
2677  * ****************************************************************/
2678 uint8_t BuildAndSendUESetReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
2679    uint16_t rrcContLen, uint8_t *rrcContainer)
2680 {
2681    uint8_t   Nrcgiret;
2682    uint8_t   SplCellListret;
2683    uint8_t   SrbSetupret;
2684    uint8_t   elementCnt;
2685    uint8_t   idx;
2686    uint8_t   idx1;
2687    F1AP_PDU_t           *f1apMsg = NULLP;
2688    UEContextSetupRequest_t *ueSetReq = NULLP;
2689    asn_enc_rval_t encRetVal;        /* Encoder return value */
2690    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2691    uint8_t ret= RFAILED;
2692    uint8_t ret1;
2693    while(true)
2694    {
2695       DU_LOG("\n F1AP : Building UE Context Setup Request\n");
2696
2697       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2698       if(f1apMsg == NULLP)
2699       {
2700          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
2701          break;
2702       }
2703
2704       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2705       CU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2706       if(f1apMsg->choice.initiatingMessage == NULLP)
2707       {
2708          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
2709          break;
2710       }
2711
2712       f1apMsg->choice.initiatingMessage->procedureCode = \
2713          ProcedureCode_id_UEContextSetup;
2714       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
2715       f1apMsg->choice.initiatingMessage->value.present = \
2716          InitiatingMessage__value_PR_UEContextSetupRequest;
2717       ueSetReq =
2718          &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2719
2720       elementCnt = 11;
2721       ueSetReq->protocolIEs.list.count = elementCnt;
2722       ueSetReq->protocolIEs.list.size = \
2723                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
2724
2725       /* Initialize the UESetup members */
2726       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2727
2728       if(ueSetReq->protocolIEs.list.array == NULLP)
2729       {
2730          DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
2731          break;
2732       }
2733
2734       for(idx1=0; idx1<elementCnt; idx1++)
2735       {
2736          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
2737          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
2738          {
2739             break;
2740          }
2741       }
2742
2743       idx = 0;
2744
2745       /*GNB CU UE F1AP ID*/
2746       ueSetReq->protocolIEs.list.array[idx]->id = \
2747                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2748       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2749       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2750                                                              UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
2751       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
2752
2753       /*GNB DU UE F1AP ID*/
2754       idx++;
2755       ueSetReq->protocolIEs.list.array[idx]->id = \
2756                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2757       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2758       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2759                                                              UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
2760       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
2761
2762       /*Special Cell ID*/
2763       idx++;
2764       ueSetReq->protocolIEs.list.array[idx]->id = \
2765                                                   ProtocolIE_ID_id_SpCell_ID;
2766       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2767       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2768                                                              UEContextSetupRequestIEs__value_PR_NRCGI;
2769       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2770       if(Nrcgiret != ROK)
2771       {
2772          break;
2773       }
2774
2775       /*Served Cell Index*/
2776       idx++;
2777       ueSetReq->protocolIEs.list.array[idx]->id = \
2778                                                   ProtocolIE_ID_id_ServCellIndex;
2779       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2780       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2781                                                              UEContextSetupRequestIEs__value_PR_ServCellIndex;
2782       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
2783                                                                           CELL_INDEX;
2784
2785       /*CellULConfigured*/
2786       idx++;
2787       ueSetReq->protocolIEs.list.array[idx]->id = \
2788                                                   ProtocolIE_ID_id_SpCellULConfigured;
2789       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2790       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2791                                                              UEContextSetupRequestIEs__value_PR_CellULConfigured;
2792       ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
2793                                                                              CellULConfigured_none;
2794
2795
2796       /*CUtoDURRCContainer*/
2797       idx++;
2798       ueSetReq->protocolIEs.list.array[idx]->id = \
2799                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
2800       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2801       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2802                                                              UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
2803
2804       /*Special Cells to be SetupList*/
2805       idx++;
2806       ueSetReq->protocolIEs.list.array[idx]->id = \
2807                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
2808       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2809       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2810                                                              UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
2811       SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2812       if(SplCellListret != ROK)
2813       {
2814          break;
2815       }
2816       /*SRBs To Be Setup List*/
2817       idx++;
2818       ueSetReq->protocolIEs.list.array[idx]->id = \
2819                                                   ProtocolIE_ID_id_SRBs_ToBeSetup_List;
2820       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2821       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2822                                                              UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
2823       SrbSetupret =     BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2824       if(SrbSetupret != ROK)
2825       {
2826          break;
2827       }
2828       /*DRBs to Be Setup List*/
2829       idx++;
2830       ueSetReq->protocolIEs.list.array[idx]->id = \
2831                                                   ProtocolIE_ID_id_DRBs_ToBeSetup_List;
2832       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2833       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2834                                                              UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
2835       ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2836       if(ret1 != ROK)
2837       {
2838          break;
2839       }
2840
2841       /* RRC Container */
2842       idx++;
2843       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
2844       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
2845       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2846          UEContextSetupRequestIEs__value_PR_RRCContainer;
2847       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = rrcContLen;
2848       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
2849           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2850       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
2851       {
2852          DU_LOG(" F1AP : Memory allocation for BuildAndSendUESetReq failed");
2853          break;
2854       }
2855       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
2856          rrcContainer, ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2857
2858       /* RRC delivery status request */
2859       idx++;
2860       ueSetReq->protocolIEs.list.array[idx]->id = \
2861          ProtocolIE_ID_id_RRCDeliveryStatusRequest;
2862       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
2863       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2864          UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
2865       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
2866          RRCDeliveryStatusRequest_true;
2867
2868       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2869
2870       /* Encode the F1SetupRequest type as APER */
2871       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2872       encBufSize = 0;
2873       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2874             encBuf);
2875       /* Encode results */
2876       if(encRetVal.encoded == ENCODE_FAIL)
2877       {
2878          DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
2879                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2880          break;
2881       }
2882       else
2883       {
2884          DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
2885          for(int i=0; i< encBufSize; i++)
2886          {
2887             printf("%x",encBuf[i]);
2888          }
2889       }
2890
2891       /* Sending  msg  */
2892       if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)    !=      ROK)
2893       {
2894          DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
2895          break;
2896       }
2897       ret = ROK;
2898       break;
2899    }
2900    FreeUESetReq(f1apMsg);
2901
2902    return ret;
2903 }/* End of BuildAndSendUESetReq*/
2904
2905 uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
2906 {
2907    uint8_t idx, ret, srbId, rrcMsgType;
2908    uint8_t cuUeF1apId, duUeF1apId;
2909    uint8_t *rrcContainer = NULLP;
2910    uint16_t rrcContLen;
2911    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
2912
2913    ret = ROK;
2914    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2915
2916    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
2917    {
2918       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
2919       {
2920          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
2921             {
2922                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
2923                break;
2924             }
2925          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2926             {
2927                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2928                break;
2929             }
2930          case ProtocolIE_ID_id_SRBID:
2931             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
2932             break;
2933          case ProtocolIE_ID_id_RRCContainer:
2934             {
2935                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
2936                CU_ALLOC(rrcContainer, rrcContLen)
2937                if(!rrcContainer)
2938                {
2939                   DU_LOG("\nCU_STUB: Failed to allocated memory in procUlRrcMsg");
2940                   return RFAILED;
2941                }
2942                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
2943                      rrcContLen);
2944                break;
2945             }
2946
2947          default:
2948             DU_LOG("\n Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
2949             break;
2950       }
2951    }
2952    if(srbId == 1)
2953    {
2954       f1apMsgDb.dlRrcMsgCount++;
2955       rrcMsgType = setDlRRCMsgType();
2956       if(rrcMsgType == RRC_SECURITY_MODE_COMMAND)
2957       {
2958          ret = BuildAndSendUESetReq(cuUeF1apId, duUeF1apId, rrcContLen, rrcContainer);
2959       }
2960       if(rrcMsgType == RRC_RECONFIG)
2961       {
2962          ret = BuildAndSendDLRRCMessageTransfer(rrcMsgType);
2963       }
2964    }
2965    return ret;
2966 }
2967
2968 /****************************************************************
2969  * @brief Build And Send F1ResetAck
2970  *
2971  * @details
2972  *
2973  *    Function : FreeF1ResetAck
2974  *
2975  *    Functionality:
2976  *         - Build And Send  F1ResetRSP
2977  *
2978  *  @params[in]
2979  * @return ROK     - success
2980  *         RFAILED - failure
2981  *
2982  * ****************************************************************/
2983 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
2984 {
2985     uint8_t idx;
2986     ResetAcknowledge_t *f1ResetAck;
2987
2988     if(f1apMsg)
2989     {
2990        if(f1apMsg->choice.successfulOutcome)
2991        {
2992           f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
2993
2994           if(f1ResetAck->protocolIEs.list.array)
2995           {
2996              for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
2997              {
2998                 if(f1ResetAck->protocolIEs.list.array[idx])
2999                 {
3000                    CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
3001                 }
3002              }
3003              CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
3004           }
3005           CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
3006        }
3007        CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3008     }
3009 }
3010
3011 /****************************************************************
3012 * @brief Build And Send F1ResetAck
3013 *
3014 * @details
3015 *
3016 *    Function : BuildAndSendF1ResetAck
3017 *
3018 *    Functionality:
3019 *         - Build And Send  F1ResetRSP
3020 *
3021 *  @params[in]
3022 * @return ROK     - success
3023 *         RFAILED - failure
3024 *
3025 * ****************************************************************/
3026
3027 uint8_t BuildAndSendF1ResetAck()
3028 {
3029    uint8_t                idx = 0;
3030    uint8_t                elementCnt = 0;
3031    uint8_t                ret = RFAILED;
3032    F1AP_PDU_t             *f1apMsg = NULL;
3033    ResetAcknowledge_t     *f1ResetAck = NULLP;
3034    asn_enc_rval_t         encRetVal;
3035    DU_LOG("\nF1AP : Building F1 Reset Acknowledgment \n");
3036
3037    do{
3038         /* Allocate the memory for F1ResetRequest_t */
3039         CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
3040         if(f1apMsg == NULLP)
3041         {
3042            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
3043            break;
3044         }
3045
3046         f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
3047
3048         CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
3049         if(f1apMsg->choice.successfulOutcome == NULLP)
3050         {
3051            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
3052            break;
3053         }
3054
3055         f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
3056         f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
3057         f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
3058         f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
3059
3060         elementCnt = 1;
3061
3062         f1ResetAck->protocolIEs.list.count = elementCnt;
3063         f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
3064
3065         CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
3066         if(f1ResetAck->protocolIEs.list.array == NULLP)
3067         {
3068            DU_LOG("\nF1AP : Memory allocation for F1ResetAckIEs failed");
3069            break;
3070         }
3071
3072         for(idx=0; idx<elementCnt; idx++)
3073         {
3074            CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
3075            if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
3076            {
3077               break;
3078            }
3079         }
3080         /*TransactionID*/
3081         idx = 0;
3082         f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
3083         f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
3084         f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
3085         f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
3086
3087         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
3088
3089         /* Encode the F1SetupRequest type as UPER */
3090         memset(encBuf, 0, ENC_BUF_MAX_LEN);
3091         encBufSize = 0;
3092         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
3093
3094         /* Check encode results */
3095         if(encRetVal.encoded == ENCODE_FAIL)
3096         {
3097            DU_LOG("\nF1AP : Could not encode F1ResetAck structure (at %s)\n",\
3098                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3099            break;
3100         }
3101         else
3102         {
3103            DU_LOG("\nF1AP : Created APER encoded buffer for F1ResetAck \n");
3104            for(int i=0; i< encBufSize; i++)
3105            {
3106               printf("%x",encBuf[i]);
3107            }
3108         }
3109         /* Sending msg */
3110         if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
3111         {
3112            DU_LOG("\nF1AP : Sending F1 Reset Response failed");
3113            break;
3114         }
3115
3116         ret = ROK;
3117         break;
3118    }while(true);
3119
3120    FreeF1ResetAck(f1apMsg);
3121    return ret;
3122 }
3123
3124 /*******************************************************************
3125  *
3126  * @brief Handles received F1AP message and sends back response
3127  *
3128  * @details
3129  *
3130  *    Function : F1APMsgHdlr
3131  *
3132  *    Functionality:
3133  *         - Decodes received F1AP control message
3134  *         - Prepares response message, encodes and sends to SCTP
3135  *
3136  * @params[in]
3137  * @return ROK     - success
3138  *         RFAILED - failure
3139  *
3140  * ****************************************************************/
3141 void F1APMsgHdlr(Buffer *mBuf)
3142 {
3143    int i;
3144    char *recvBuf;
3145    MsgLen copyCnt;
3146    MsgLen recvBufLen;
3147    F1AP_PDU_t *f1apMsg = NULLP;
3148    asn_dec_rval_t rval; /* Decoder return value */
3149    F1AP_PDU_t f1apasnmsg ;
3150
3151    DU_LOG("\nF1AP : Received F1AP message buffer");
3152    ODU_PRINT_MSG(mBuf, 0,0);
3153
3154    /* Copy mBuf into char array to decode it */
3155    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
3156    CU_ALLOC(recvBuf, (Size)recvBufLen);
3157
3158    if(recvBuf == NULLP)
3159    {
3160       DU_LOG("\nF1AP : Memory allocation failed");
3161       return;
3162    }
3163    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
3164    {
3165       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
3166       return;
3167    }
3168
3169    printf("\nF1AP : Received flat buffer to be decoded : ");
3170    for(i=0; i< recvBufLen; i++)
3171    {
3172       printf("%x",recvBuf[i]);
3173    }
3174
3175    /* Decoding flat buffer into F1AP messsage */
3176    f1apMsg = &f1apasnmsg;
3177    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
3178
3179    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
3180    CU_FREE(recvBuf, (Size)recvBufLen);
3181
3182    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
3183    {
3184       DU_LOG("\nF1AP : ASN decode failed");
3185       return;
3186    }
3187    printf("\n");
3188    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
3189
3190    switch(f1apMsg->present)
3191    {
3192       case F1AP_PDU_PR_initiatingMessage:
3193       {
3194          switch(f1apMsg->choice.initiatingMessage->value.present)
3195          {
3196             case InitiatingMessage__value_PR_Reset:
3197             {
3198                 DU_LOG("\nF1AP : F1 reset request received ");
3199                 BuildAndSendF1ResetAck();
3200                 break;
3201             }
3202
3203             case InitiatingMessage__value_PR_F1SetupRequest:
3204             {
3205                DU_LOG("\nF1AP : F1 setup request received");
3206                BuildAndSendF1SetupRsp();
3207                break;
3208             }
3209
3210             case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
3211             {
3212                DU_LOG("\nF1AP : GNB-DU config update received");
3213                BuildAndSendDUUpdateAck();
3214                DU_LOG("\nF1AP : Sending F1 reset request");
3215                BuildAndSendF1ResetReq();
3216                break;
3217             }
3218             case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
3219             {
3220                DU_LOG("\nF1AP : Received InitialULRRCMessageTransfer");
3221                procInitULRRCMsg(f1apMsg);
3222                break;
3223             }
3224             case InitiatingMessage__value_PR_ULRRCMessageTransfer:
3225             {
3226                DU_LOG("\nF1AP : Received ULRRCMessageTransfer");
3227                procUlRrcMsg(f1apMsg);
3228                break;
3229             }
3230
3231             case InitiatingMessage__value_PR_RRCDeliveryReport:
3232             {
3233                DU_LOG("\nF1AP : Received RRC delivery report");
3234                 break;
3235             }
3236             default:
3237             {
3238                DU_LOG("\nF1AP : Invalid type of intiating message [%d]",f1apMsg->choice.initiatingMessage->value.present);
3239                return;
3240             }
3241          }/* End of switch(initiatingMessage) */
3242          break;
3243       }
3244
3245       case F1AP_PDU_PR_successfulOutcome:
3246       {
3247          switch(f1apMsg->choice.successfulOutcome->value.present)
3248          {
3249             case SuccessfulOutcome__value_PR_ResetAcknowledge:
3250             {
3251                DU_LOG("\nF1Reset Acknowledgement is received successfully ");
3252                break;
3253             }
3254          }/* End of switch(successfulOutcome) */
3255          break;
3256       }
3257       default:
3258          {
3259             DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
3260             return;
3261          }
3262    }/* End of switch(f1apMsg->present) */
3263
3264 } /* End of F1APMsgHdlr */
3265
3266 /**********************************************************************
3267   End of file
3268  **********************************************************************/