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 : fillRadioBearerConfig
 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 fillRadioBearerConfig(SRB_ToAddModList_t *bearerCfg)
 824 {
 825    uint8_t elementCnt;
 826    uint8_t idx;
 827    uint8_t ied;
 828    if(bearerCfg != NULLP)
 829    {
 830       elementCnt = 1;
 831       bearerCfg->list.count = elementCnt;
 832       bearerCfg->list.size =\
 833                             elementCnt * sizeof(SRB_ToAddMod_t *);
 834       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 835       if(bearerCfg->list.array != NULLP)
 836       {
 837          for(idx = 0; idx < elementCnt; idx++)
 838          {
 839             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 840             if(bearerCfg->list.array[idx] == NULLP)
 841             {
 842                for(ied = 0; ied < idx; ied++)
 843                {
 844                   CU_FREE(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 845                }
 846                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 847                return RFAILED;
 848             }
 849          }
 850       }
 851       else
 852       {
 853          return RFAILED;
 854       }
 855       idx = 0;
 856       bearerCfg->list.array[idx]->srb_Identity = SRB1;
 857    }
 858    return ROK;
 859 }
 860
 861 /*******************************************************************
 862  *
 863  * @brief Fills Master CellGroup Info
 864  *
 865  * @details
 866  *
 867  *    Function : fillMasterCellGroup
 868  *
 869  *    Functionality: Fills Master Cell Group IE
 870  *
 871  * @params[in] RRCSetup_IEs_t *
 872  *
 873  * @return ROK     - success
 874  *         RFAILED - failure
 875  *
 876  * ****************************************************************/
 877
 878 uint8_t fillMasterCellGroup(OCTET_STRING_t *masterCellGroup)
 879 {
 880    uint8_t ret = ROK;
 881    masterCellGroup->buf = NULLP;
 882    if(f1apMsgDb.duToCuContainer.buf)
 883    {
 884       masterCellGroup->size = f1apMsgDb.duToCuContainer.size;
 885       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 886       if(masterCellGroup->buf != NULLP)
 887       {
 888          memcpy(masterCellGroup->buf, f1apMsgDb.duToCuContainer.buf,\
 889                masterCellGroup->size);
 890       }
 891       else
 892       {
 893          ret = RFAILED;
 894       }
 895    }
 896    else
 897    {
 898       ret =  RFAILED;
 899    }
 900    return ret;
 901 }
 902
 903 /*******************************************************************
 904  *
 905  * @brief Fills RRC setup IE
 906  *
 907  * @details
 908  *
 909  *    Function : fillRRCSetupIE
 910  *
 911  *    Functionality: Fills RRC Setup IE
 912  *
 913  * @params[in] RRCSetup_IEs_t *
 914  *
 915  * @return ROK     - success
 916  *         RFAILED - failure
 917  *
 918  * ****************************************************************/
 919
 920 uint8_t fillRRCSetupIE(RRCSetup_IEs_t *rrcSetupIE)
 921 {
 922    uint8_t ret = ROK;
 923    if(rrcSetupIE)
 924    {
 925       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
 926       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
 927       {
 928          ret = fillRadioBearerConfig(rrcSetupIE->radioBearerConfig.srb_ToAddModList);
 929       }
 930       if(!ret)
 931       {
 932          ret = fillMasterCellGroup(&rrcSetupIE->masterCellGroup);
 933       }
 934       else
 935       {
 936          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
 937          ret = RFAILED;
 938       }
 939    }
 940    return ret;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
 945  *
 946  * @details
 947  *
 948  *    Function : BuildDLRRCContainer
 949  *
 950  *    Functionality: Builds RRC Container IE required for
 951  *                   DLRRCMessageTransfer
 952  *
 953  * @params[in]
 954  *
 955  * @return ROK     - success
 956  *         RFAILED - failure
 957  *
 958  * ****************************************************************/
 959
 960 uint8_t BuildDLRRCContainer(RRCContainer_t *rrcContainer)
 961 {
 962    uint8_t ret = ROK;
 963    uint16_t idx2;
 964    DL_CCCH_Message_t dl_CCCH_Msg;
 965    asn_enc_rval_t        encRetVal;
 966
 967    if(rrcContainer != NULLP)
 968    {
 969       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
 970
 971       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
 972       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
 973       {
 974          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
 975          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
 976          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
 977          {
 978             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
 979             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
 980                present = RRCSetup__criticalExtensions_PR_rrcSetup;
 981             /* Fill RRC Setup IE */
 982             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 983                   criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
 984             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 985                   criticalExtensions.choice.rrcSetup != NULLP)
 986             {
 987                ret = fillRRCSetupIE(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 988                      criticalExtensions.choice.rrcSetup);
 989
 990                if(!ret)
 991                {
 992                   /* encode DL-CCCH message into RRC Container */
 993                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
 994                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
 995                   encBufSize = 0;
 996                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
 997                   /* Encode results */
 998                   if(encRetVal.encoded == ENCODE_FAIL)
 999                   {
1000                      DU_LOG( "\n F1AP : Could not encode RRCContainer (at %s)\n",\
1001                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1002                      return RFAILED;
1003                   }
1004                   else
1005                   {
1006                      DU_LOG("\n F1AP : Created APER encoded buffer for RRCContainer\n");
1007                      for(int i = 0; i< encBufSize; i++)
1008                      {
1009                         printf("%x",encBuf[i]);
1010                      }
1011                      rrcContainer->size = encBufSize;
1012                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1013                      if(rrcContainer->buf != NULLP)
1014                      {
1015                         memset(rrcContainer->buf, 0, encBufSize);
1016                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1017                         {
1018                            rrcContainer->buf[idx2] =    encBuf[idx2];
1019                         }
1020                      }
1021                   }
1022                }
1023                else
1024                {
1025                   ret = RFAILED;
1026                }
1027             }
1028             else
1029             {
1030                DU_LOG("\nF1AP: Memory Alloc failed for RRC Setup Msg");
1031                ret = RFAILED;
1032             }
1033          }
1034          else
1035          {
1036             DU_LOG("\nF1AP: Memory Alloc failed for RRC Msg");
1037             ret = RFAILED;
1038          }
1039       }
1040       else
1041       {
1042          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice");
1043          ret = RFAILED;
1044       }
1045    }
1046    else
1047    {
1048       DU_LOG("\nF1AP: Memory Alloc failed for DlCcch Msg");
1049       ret = RFAILED;
1050    }
1051    return ret;
1052 }
1053
1054 /*******************************************************************
1055  *
1056  * @brief Builds and sends the DLRRCMessageTransfer
1057  *
1058  * @details
1059  *
1060  *    Function : BuildAndSendDLRRCMessageTransfer
1061  *
1062  *    Functionality: Constructs the DL RRC Message Transfer and sends
1063  *                   it to the CU through SCTP.
1064  *
1065  * @params[in]
1066  *
1067  * @return ROK     - success
1068  *         RFAILED - failure
1069  *
1070  * ****************************************************************/
1071 S16 BuildAndSendDLRRCMessageTransfer()
1072 {
1073    uint8_t   elementCnt = 0;
1074    uint8_t  ieId;
1075    uint8_t  idx;
1076    uint16_t idx2;
1077    F1AP_PDU_t  *f1apMsg = NULLP;
1078    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1079    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1080
1081    DU_LOG("\n F1AP : Building DL RRC Message Transfer Message\n");
1082
1083    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1084    if(f1apMsg == NULLP)
1085    {
1086       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1087       return RFAILED;
1088    }
1089
1090    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1091    CU_ALLOC(f1apMsg->choice.initiatingMessage,
1092          sizeof(InitiatingMessage_t));
1093    if(f1apMsg->choice.initiatingMessage == NULLP)
1094    {
1095       DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
1096       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1097       return RFAILED;
1098    }
1099
1100    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1101    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1102    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1103    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1104
1105    elementCnt = 4;
1106    dlRRCMsg->protocolIEs.list.count = elementCnt;
1107    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1108
1109    /* Initialize the F1Setup members */
1110    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1111    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1112    {
1113       DU_LOG(" F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1114       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1115       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1116       return RFAILED;
1117    }
1118
1119    for(idx=0; idx<elementCnt; idx++)
1120    {
1121       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1122       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1123       {
1124          for(ieId=0; ieId<idx; ieId++)
1125          {
1126             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId],\
1127                   sizeof(DLRRCMessageTransferIEs_t));
1128          }
1129          CU_FREE(dlRRCMsg->protocolIEs.list.array,\
1130                dlRRCMsg->protocolIEs.list.size);
1131          CU_FREE(f1apMsg->choice.initiatingMessage,\
1132                sizeof(InitiatingMessage_t));
1133          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1134          return RFAILED;
1135       }
1136    }
1137
1138    /* GNB CU UE F1AP ID */
1139    idx = 0;
1140    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1141    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1142    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1143                                                           DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1144    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
1145
1146    /* GNB DU UE F1AP ID */
1147    idx++;
1148    dlRRCMsg->protocolIEs.list.array[idx]->id  = \
1149                                                 ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1150    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1151    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1152                                                           DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1153    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
1154
1155    /* SRBID */
1156    idx++;
1157    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1158    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1159    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1160                                                           DLRRCMessageTransferIEs__value_PR_SRBID;
1161    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = SRB1;
1162
1163    /* RRCContainer */
1164    idx++;
1165    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1166    dlRRCMsg->protocolIEs.list.array[idx]->criticality   = Criticality_reject;
1167    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1168                                                           DLRRCMessageTransferIEs__value_PR_RRCContainer;
1169    BuildDLRRCContainer(&dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1170
1171    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1172
1173    /* Encode the F1SetupRequest type as APER */
1174    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1175    encBufSize = 0;
1176    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1177          encBuf);
1178    /* Encode results */
1179    if(encRetVal.encoded == ENCODE_FAIL)
1180    {
1181       DU_LOG( "\n F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1182             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1183       return RFAILED;
1184    }
1185    else
1186    {
1187       DU_LOG("\n F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1188       for(int i=0; i< encBufSize; i++)
1189       {
1190          printf("%x",encBuf[i]);
1191       }
1192    }
1193
1194    /* Sending  msg  */
1195    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=  ROK)
1196    {
1197       DU_LOG("\n F1AP : Sending  DL RRC Message Transfer Failed");
1198       return RFAILED;
1199    }
1200
1201    return ROK;
1202 }/* End of BuildAndSendDLRRCMessageTransfer */
1203
1204 /*******************************************************************
1205  *
1206  * @brief Builds and sends the UE Setup Response
1207  *
1208  * @details
1209  *
1210  *    Function : BuildAndSendUESetRsp
1211  *
1212  *    Functionality: Constructs the UE Setup Response and sends
1213  *                   it to the DU through SCTP.
1214  *
1215  * @params[in]
1216  *
1217  * @return ROK     - success
1218  *         RFAILED - failure
1219  *
1220  * ****************************************************************/
1221 S16 BuildAndSendUESetRsp()
1222 {
1223    S16  ret;
1224    U8   elementCnt;
1225    U8   cellCnt;
1226    U8   ieId;
1227    U8   idx;
1228    U8   drbCnt;
1229    U8   drbId;
1230    F1AP_PDU_t                                                   *f1apMsg = NULL;
1231    UEContextSetupResponse_t                     *ueSetRsp;
1232    asn_enc_rval_t                                               encRetVal;        /* Encoder return value */
1233
1234    DU_LOG("\n F1AP : Building UE Context Setup Response\n");
1235
1236    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1237    if(f1apMsg == NULLP)
1238    {
1239       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1240       return RFAILED;
1241    }
1242
1243    f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
1244    CU_ALLOC(f1apMsg->choice.successfulOutcome,
1245          sizeof(SuccessfulOutcome_t));
1246    if(f1apMsg->choice.successfulOutcome == NULLP)
1247    {
1248       DU_LOG(" F1AP : Memory allocation for     F1AP-PDU failed");
1249       CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1250       return RFAILED;
1251    }
1252
1253    f1apMsg->choice.successfulOutcome->procedureCode = \
1254                                                       ProcedureCode_id_UEContextSetup;
1255    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
1256    f1apMsg->choice.successfulOutcome->value.present = \
1257                                                       SuccessfulOutcome__value_PR_UEContextSetupResponse;
1258    ueSetRsp =
1259       &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
1260    elementCnt = 2;
1261    ueSetRsp->protocolIEs.list.count = elementCnt;
1262    ueSetRsp->protocolIEs.list.size = \
1263                                      elementCnt * sizeof(UEContextSetupResponse_t *);
1264
1265    /* Initialize the UESetup members */
1266    CU_ALLOC(ueSetRsp->protocolIEs.list.array, \
1267          ueSetRsp->protocolIEs.list.size);
1268    if(ueSetRsp->protocolIEs.list.array == NULLP)
1269    {
1270       DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
1271       CU_FREE(f1apMsg->choice.successfulOutcome,
1272             sizeof(SuccessfulOutcome_t));
1273       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
1274       return RFAILED;
1275    }
1276
1277    for(idx=0; idx<elementCnt; idx++)
1278    {
1279       CU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
1280             sizeof(UEContextSetupResponseIEs_t));
1281       if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
1282       {
1283          for(ieId=0; ieId<idx; ieId++)
1284          {
1285             CU_FREE(ueSetRsp->protocolIEs.list.array[ieId],\
1286                   sizeof(UEContextSetupResponseIEs_t));
1287          }
1288          CU_FREE(ueSetRsp->protocolIEs.list.array,\
1289                ueSetRsp->protocolIEs.list.size);
1290          CU_FREE(f1apMsg->choice.successfulOutcome,\
1291                sizeof(SuccessfulOutcome_t));
1292          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1293          return RFAILED;
1294       }
1295    }
1296
1297    idx = 0;
1298
1299    /*GNB CU UE F1AP ID*/
1300    ueSetRsp->protocolIEs.list.array[idx]->id    = \
1301                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1302    ueSetRsp->protocolIEs.list.array[idx]->criticality   =       Criticality_reject;
1303    ueSetRsp->protocolIEs.list.array[idx]->value.present = \
1304                                                           UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
1305    ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
1306
1307    /*GNB DU UE F1AP ID*/
1308    idx++;
1309    ueSetRsp->protocolIEs.list.array[idx]->id    = \
1310                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1311    ueSetRsp->protocolIEs.list.array[idx]->criticality   =       Criticality_reject;
1312    ueSetRsp->protocolIEs.list.array[idx]->value.present = \
1313                                                           UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
1314    ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
1315
1316
1317    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1318
1319    /* Encode the F1SetupRequest type as APER */
1320    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1321    encBufSize = 0;
1322    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1323          encBuf);
1324    /* Encode results */
1325    if(encRetVal.encoded == ENCODE_FAIL)
1326    {
1327       DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
1328             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1329       return RFAILED;
1330    }
1331    else
1332    {
1333       DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
1334       for(int i=0; i< encBufSize; i++)
1335       {
1336          printf("%x",encBuf[i]);
1337       }
1338    }
1339
1340    /* Sending  msg  */
1341    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)       !=      ROK)
1342    {
1343       DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
1344       return RFAILED;
1345    }
1346
1347    return ROK;
1348 }/* End of BuildAndSendUESetRsp */
1349
1350 uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
1351 {
1352    uint8_t idx;
1353    uint8_t ret =ROK;
1354    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1355    DU_LOG("\n filling the required values in DB in procInitULRRCMsg");
1356
1357    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1358
1359    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
1360    {
1361       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
1362       {
1363          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
1364             break;
1365          case ProtocolIE_ID_id_NRCGI:
1366             break;
1367          case ProtocolIE_ID_id_C_RNTI:
1368             break;
1369          case ProtocolIE_ID_id_RRCContainer:
1370             break;
1371          case ProtocolIE_ID_id_DUtoCURRCContainer:
1372             {
1373                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
1374                         .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
1375                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
1376                {
1377                   DU_LOG("\n Received Du to Cu RRC Container ");
1378                   f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
1379                                                    .list.array[idx]->value.choice.DUtoCURRCContainer.size;
1380                   CU_ALLOC(f1apMsgDb.duToCuContainer.buf, \
1381                         f1apMsgDb.duToCuContainer.size);
1382                   if(f1apMsgDb.duToCuContainer.buf != NULLP)
1383                   {
1384                      memcpy(f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
1385                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf, f1apMsgDb\
1386                            .duToCuContainer.size);
1387                   }
1388                }
1389                else
1390                {
1391                   DU_LOG("\n Failed to receive Du to Cu RRC Container ");
1392                   ret = RFAILED;
1393                }
1394                break;
1395             }
1396          default:
1397             DU_LOG("\n Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
1398             break;
1399       }
1400    }
1401    if(!ret)
1402       ret = BuildAndSendDLRRCMessageTransfer();
1403
1404    return ret;
1405 }
1406
1407 /*******************************************************************
1408  *
1409  * @brief Builds Nrcgi
1410  *
1411  * @details
1412  *
1413  *    Function : BuildNrcgi
1414  *
1415  *    Functionality: Building the PLMN ID and NR Cell id
1416  *
1417  * @params[in] NRCGI_t *nrcgi
1418  * @return ROK     - success
1419  *         RFAILED - failure
1420  *
1421  * ****************************************************************/
1422 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
1423 {
1424    uint8_t ret;
1425    uint8_t unused = 4;
1426    uint8_t byteSize = 5;
1427    uint8_t val = 16;
1428    /* Allocate Buffer Memory */
1429    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
1430    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1431    if(nrcgi->pLMN_Identity.buf == NULLP)
1432    {
1433       return RFAILED;
1434    }
1435    ret = buildPlmnId(cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
1436
1437    if(ret != ROK)
1438    {
1439       return RFAILED;
1440    }
1441    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
1442    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1443    if(nrcgi->nRCellIdentity.buf == NULLP)
1444    {
1445       return RFAILED;
1446    }
1447    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
1448    if(ret != ROK)
1449    {
1450       return RFAILED;
1451    }
1452    return ROK;
1453 }
1454 /*******************************************************************
1455  *
1456  * @brief Builds Special cell list for UE Setup Request
1457  *
1458  * @details
1459  *
1460  *    Function : BuildSplCellList
1461  *
1462  *    Functionality: Constructs the Special Cell list for UESetReq
1463  *
1464  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1465  *
1466  * @return ROK     - success
1467  *         RFAILED - failure
1468  *
1469  * ****************************************************************/
1470 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1471 {
1472    uint8_t  cellCnt;
1473    uint8_t  idx;
1474    uint8_t  ret;
1475    cellCnt = 1;
1476    spCellLst->list.count = cellCnt;
1477    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
1478    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
1479    if(spCellLst->list.array == NULLP)
1480    {
1481       return RFAILED;
1482    }
1483    for(idx=0; idx<cellCnt; idx++)
1484    {
1485       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1486       if(spCellLst->list.array[idx] == NULLP)
1487       {
1488          return RFAILED;
1489       }
1490    }
1491    idx = 0;
1492    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
1493    spCellLst->list.array[idx]->criticality = Criticality_ignore;
1494    spCellLst->list.array[idx]->value.present =\
1495                                               SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
1496    /* Special Cell ID -NRCGI */
1497    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1498    if(ret != ROK)
1499    {
1500       return RFAILED;
1501    }
1502    /*Special Cell Index*/
1503    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
1504    return ROK;
1505 }/* End of BuildSplCellList*/
1506
1507 /*******************************************************************
1508  *
1509  * @brief Builds SRBS to be setup
1510  *
1511  * @details
1512  *
1513  *    Function : BuildSRBSetup
1514  *
1515  *    Functionality: Constructs the SRB's for UESetReq
1516  *
1517  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1518  *
1519  * @return ROK     - success
1520  *         RFAILED - failure
1521  *
1522  * ****************************************************************/
1523 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1524 {
1525    uint8_t idx;
1526    uint8_t srbCnt;
1527    srbCnt = 1;
1528    srbSet->list.count = srbCnt;
1529    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
1530    CU_ALLOC(srbSet->list.array,srbSet->list.size);
1531    if(srbSet->list.array == NULLP)
1532    {
1533       return RFAILED;
1534    }
1535    for(idx=0; idx<srbCnt; idx++)
1536    {
1537       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1538       if(srbSet->list.array[idx] == NULLP)
1539       {
1540          return RFAILED;
1541       }
1542    }
1543    idx = 0;
1544    srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
1545    srbSet->list.array[idx]->criticality = Criticality_ignore;
1546    srbSet->list.array[idx]->value.present = \
1547       SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
1548    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
1549    return ROK;
1550 }/* End of BuildSRBSetup*/
1551
1552 /*******************************************************************
1553  *
1554  * @brief Builds QOS Info for DRB Setum Item
1555  *
1556  * @details
1557  *
1558  *    Function : BuildQOSInfo
1559  *
1560  *    Functionality: Constructs the QOS Info for DRB Setup Item
1561  *
1562  * @params[in] QoSInformation_t *qosinfo
1563  *
1564  * @return ROK     - success
1565  *         RFAILED - failure
1566  *
1567  * ****************************************************************/
1568 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
1569 {
1570    /* NonDynamic5QIDescriptor */
1571    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
1572    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
1573    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
1574    {
1575       return RFAILED;
1576    }
1577    /*FiveQI*/
1578    drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
1579    /*AveragingWindow*/
1580    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
1581          sizeof(AveragingWindow_t));
1582    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
1583          NULLP)
1584    {
1585       return RFAILED;
1586    }
1587    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
1588    /*MaxDataBurstVolume*/
1589    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
1590          sizeof(MaxDataBurstVolume_t));
1591    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
1592          NULLP)
1593    {
1594       return RFAILED;
1595    }
1596    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
1597
1598    /*nRGRAN Allocation Retention Priority*/
1599    drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_highest;
1600    drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
1601    drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
1602
1603    /* TO DO: GBR_QoSFlowInformation */
1604    return ROK;
1605 }/*End of BuildQOSInfo*/
1606
1607 /*******************************************************************
1608  *
1609  * @brief Builds SNSSAI
1610  *
1611  * @details
1612  *
1613  *    Function : BuildSNSSAI
1614  *
1615  *    Functionality: Constructs the SNSSAI For DRB list
1616  *
1617  * @params[in] SNSSAI_t *snssai
1618  *
1619  * @return ROK     - success
1620  *         RFAILED - failure
1621  *
1622  * ****************************************************************/
1623 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
1624 {
1625    /*SNSSAI*/
1626    /*ssT*/
1627    snssai->sST.size = sizeof(uint8_t);
1628    CU_ALLOC(snssai->sST.buf,snssai->sST.size);
1629    if(snssai->sST.buf == NULLP)
1630    {
1631       return RFAILED;
1632    }
1633    snssai->sST.buf[0] = 3;
1634    /*sD*/
1635    CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
1636    if(snssai->sD == NULLP)
1637    {
1638       return RFAILED;
1639    }
1640    snssai->sD->size = 3*sizeof(uint8_t);
1641    CU_ALLOC(snssai->sD->buf,snssai->sD->size);
1642    if(snssai->sD->buf == NULLP)
1643    {
1644       return RFAILED;
1645    }
1646    snssai->sD->buf[0] = 3;
1647    snssai->sD->buf[1] = 6;
1648    snssai->sD->buf[2] = 9;
1649    return ROK;
1650 }/*End of BuildSNSSAI*/
1651
1652 /*******************************************************************
1653  *
1654  * @brief Builds the flow map.
1655  *
1656  * @details
1657  *
1658  *    Function : BuildFlowsMap
1659  *
1660  *    Functionality: Constructs the flowmap For DRB list
1661  *
1662  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
1663  *
1664  * @return ROK     - success
1665  *         RFAILED - failure
1666  *
1667  * ****************************************************************/
1668 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
1669 {
1670    uint8_t  ret;
1671    uint8_t  idx;
1672    uint8_t  flowCnt;
1673    flowCnt = 1;
1674    flowMap->list.count = flowCnt;
1675    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
1676    CU_ALLOC(flowMap->list.array,flowMap->list.size);
1677    if(flowMap->list.array == NULLP)
1678    {
1679       return RFAILED;
1680    }
1681    for(idx=0; idx<flowCnt; idx++)
1682    {
1683       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
1684       if(flowMap->list.array[idx] == NULLP)
1685       {
1686          return RFAILED;
1687       }
1688    }
1689    idx = 0;
1690    flowMap->list.array[idx]->qoSFlowIdentifier = 0;
1691    ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
1692    if(ret != ROK)
1693    {
1694       return RFAILED;
1695    }
1696    return ROK;
1697 }/*End of BuildFlowsMap*/
1698
1699 /*******************************************************************
1700  *
1701  * @brief Builds the Uplink Tunnel Info
1702  *
1703  * @details
1704  *
1705  *    Function : BuildULTnlInfo
1706  *
1707  *    Functionality: Constructs the UL TnlInfo For DRB list
1708  *
1709  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
1710  *
1711  * @return ROK     - success
1712  *         RFAILED - failure
1713  *
1714  * ****************************************************************/
1715 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
1716 {
1717    uint8_t idx;
1718    uint8_t ulCnt;
1719    ulCnt = 1;
1720    ulInfo->list.count = ulCnt;
1721    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
1722    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
1723    if(ulInfo->list.array == NULLP)
1724    {
1725       return RFAILED;
1726    }
1727    for(idx=0; idx<ulCnt; idx++)
1728    {
1729       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
1730       if(ulInfo->list.array[idx] == NULLP)
1731       {
1732          return RFAILED;
1733       }
1734    }
1735    idx = 0;
1736    ulInfo->list.array[idx]->uLUPTNLInformation.present = \
1737                                                          UPTransportLayerInformation_PR_gTPTunnel;
1738    /*GTP TUNNEL*/
1739    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
1740          sizeof(GTPTunnel_t));
1741    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
1742    {
1743       return RFAILED;
1744    }
1745    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1746       transportLayerAddress.size        = 4*sizeof(uint8_t);
1747    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1748          transportLayerAddress.buf,ulInfo->list.array[idx]->\
1749          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
1750    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1751          transportLayerAddress.buf == NULLP)
1752    {
1753       return RFAILED;
1754    }
1755    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1756       transportLayerAddress.buf[0] = 4;
1757    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1758       transportLayerAddress.buf[1] = 4;
1759    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1760       transportLayerAddress.buf[2] = 4;
1761    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1762       transportLayerAddress.buf[3] = 5;
1763    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1764       transportLayerAddress.bits_unused = 0;
1765    /*GTP TEID*/
1766    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
1767       = 4 * sizeof(uint8_t);
1768    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1769          gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
1770          gTPTunnel->gTP_TEID.size);
1771    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
1772          == NULLP)
1773    {
1774       return RFAILED;
1775    }
1776    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1777       gTP_TEID.buf[0] = 11;
1778    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1779       gTP_TEID.buf[1] = 0;
1780    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1781       gTP_TEID.buf[2] = 0;
1782    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1783       gTP_TEID.buf[3] = 1;
1784
1785    return ROK;
1786 }/*End of BuildULTnlInfo*/
1787
1788 /*******************************************************************
1789  *
1790  * @brief Builds DRBS to be setup
1791  *
1792  * @details
1793  *
1794  *    Function : BuildDRBSetup
1795  *
1796  *    Functionality: Constructs the DRB's for UESetReq
1797  *
1798  * @params[in] DRBs_ToBeSetup_List_t *drbSet
1799  *
1800  * @return ROK     - success
1801  *         RFAILED - failure
1802  *
1803  * ****************************************************************/
1804 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
1805 {
1806    uint8_t BuildQOSInforet;
1807    uint8_t BuildSNSSAIret;
1808    uint8_t BuildFlowsMapret;
1809    uint8_t BuildULTnlInforet;
1810    uint8_t idx;
1811    uint8_t drbCnt;
1812    DRBs_ToBeSetup_Item_t *drbSetItem;
1813    drbCnt = 1;
1814    drbSet->list.count = drbCnt;
1815    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
1816    CU_ALLOC(drbSet->list.array,drbSet->list.size);
1817    if(drbSet->list.array == NULLP)
1818    {
1819       return RFAILED;
1820    }
1821    for(idx=0; idx<drbCnt; idx++)
1822    {
1823       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
1824       if(drbSet->list.array[idx] == NULLP)
1825       {
1826          return RFAILED;
1827       }
1828    }
1829    idx = 0;
1830    drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
1831    drbSet->list.array[idx]->criticality = Criticality_ignore;
1832    drbSet->list.array[idx]->value.present = \
1833                                             DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
1834    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
1835    /*dRBID*/
1836    drbSetItem->dRBID = 1;
1837    /*qoSInformation*/
1838    drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
1839    CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
1840    if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
1841    {
1842       return RFAILED;
1843    }
1844    drbSetItem->qoSInformation.choice.choice_extension->id = \
1845                                                             ProtocolIE_ID_id_DRB_Information;
1846    drbSetItem->qoSInformation.choice.choice_extension->criticality = \
1847                                                                      Criticality_ignore;
1848    drbSetItem->qoSInformation.choice.choice_extension->value.present = \
1849                                                                        QoSInformation_ExtIEs__value_PR_DRB_Information;
1850   BuildQOSInforet =  BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
1851          choice_extension->value.choice.DRB_Information.dRB_QoS);
1852    if(BuildQOSInforet != ROK)
1853    {
1854       return RFAILED;
1855    }
1856    /*SNSSAI*/
1857    BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
1858          choice_extension->value.choice.DRB_Information.sNSSAI);
1859    if(BuildSNSSAIret != ROK)
1860    {
1861       return RFAILED;
1862    }
1863    /*Flows mapped to DRB List*/
1864    BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
1865          choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
1866    if(BuildFlowsMapret != ROK)
1867    {
1868       return RFAILED;
1869    }
1870    /*ULUPTNLInformation To Be Setup List*/
1871    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
1872    if(BuildULTnlInforet != ROK)
1873    {
1874       return RFAILED;
1875    }
1876    /*RLCMode*/
1877    drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
1878
1879    /*UL Configuration*/
1880    CU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
1881    if(drbSetItem->uLConfiguration == NULLP)
1882    {
1883       return RFAILED;
1884    }
1885    drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
1886    return ROK;
1887 }/* End of BuildDRBSetup*/
1888
1889 /*******************************************************************
1890  *
1891  * @brief Deallocating memory of function BuildAndSendUESetReq
1892  *
1893  * @details
1894  *
1895  *    Function : FreeNrcgi
1896  *
1897  *    Functionality: Deallocating memory for function BuildNrcgi
1898  *
1899  * @params[in] NRCGI_t *nrcgi
1900  *
1901  * @return void
1902  *
1903  *******************************************************************/
1904 void FreeNrcgi(NRCGI_t *nrcgi)
1905 {
1906    if(nrcgi->pLMN_Identity.buf != NULLP)
1907    {
1908       if(nrcgi->nRCellIdentity.buf != NULLP)
1909       {
1910          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1911       }
1912       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1913    }
1914 }
1915 /*******************************************************************
1916  *
1917  * @brief  Deallocating memory of function BuildAndSendUESetReq
1918  *
1919  * @details
1920  *
1921  *    Function : FreeSplCellList
1922  *
1923  *    Functionality: Deallocating memory for function BuildSplCellList
1924  *
1925  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1926  *
1927  * @return void
1928  *
1929  *
1930  * *****************************************************************/
1931 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1932 {
1933    uint8_t  cellidx;
1934    if(spCellLst->list.array != NULLP)
1935    {
1936       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
1937       {
1938          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
1939          {
1940             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1941          }
1942          if(spCellLst->list.array[cellidx]!=NULLP)
1943          {
1944             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1945          }
1946       }
1947       CU_FREE(spCellLst->list.array,spCellLst->list.size);
1948    }
1949 }
1950 /*******************************************************************
1951  *
1952  * @brief Deallocating memory of function BuildAndSendUESetReq
1953  *
1954  * @details
1955  *
1956  *    Function : FreeSRBSetup
1957  *
1958  *    Functionality: Deallocating memory for function BuildSRBSetup
1959  *
1960  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1961  *
1962  * @return void
1963  *
1964  *
1965  * ******************************************************************/
1966 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1967 {
1968    uint8_t srbidx;
1969    if(srbSet->list.array != NULLP)
1970    {
1971       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
1972       {
1973          if(srbSet->list.array[srbidx]!=NULLP)
1974          {
1975             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1976          }
1977       }
1978       CU_FREE(srbSet->list.array,srbSet->list.size);
1979    }
1980 }
1981 /*******************************************************************
1982  *
1983  * @brief Deallocating memory of function BuildAndSendUESetReq
1984  *
1985  * @details
1986  *
1987  *    Function : FreeQOSInfo
1988  *
1989  *    Functionality:  Deallocating memory for function BuildQOSInfo
1990  *
1991  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
1992  *
1993  * @return void
1994  *
1995  * ****************************************************************/
1996 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
1997 {
1998    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
1999    {
2000       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2001       {
2002          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2003          {
2004             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2005                   sizeof(MaxDataBurstVolume_t));
2006          }
2007          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2008                sizeof(AveragingWindow_t));
2009       }
2010       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2011             sizeof(NonDynamic5QIDescriptor_t));
2012    }
2013 }
2014 /*******************************************************************
2015  *
2016  * @brief Deallocating memory of function BuildAndSendUESetReq
2017  *
2018  * @details
2019  *
2020  *    Function : FreeULTnlInfo
2021  *
2022  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2023  *
2024  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2025  *
2026  * @return void
2027  *
2028
2029  * ****************************************************************/
2030 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2031 {
2032    uint8_t ulidx=0;
2033    if(ulInfo->list.array != NULLP)
2034    {
2035       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2036       {
2037          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2038          {
2039             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2040             {
2041                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2042                      transportLayerAddress.buf != NULLP)
2043                {
2044                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2045                         !=NULLP)
2046                   {
2047                      CU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2048                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2049                            gTPTunnel->gTP_TEID.size);
2050                   }
2051                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2052                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2053                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2054                }
2055                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2056                      sizeof(GTPTunnel_t));
2057             }
2058          }
2059          if(ulInfo->list.array[ulidx]!=NULLP)
2060          {
2061             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2062          }
2063       }
2064       CU_FREE(ulInfo->list.array,ulInfo->list.size);
2065    }
2066 }
2067 /*******************************************************************
2068  *
2069  * @brief Deallocating memory for BuildAndSendUESetReq
2070  *
2071  * @details
2072  *
2073  *    Function : FreeDRBSetup
2074  *
2075  *    Functionality:  Deallocating memory for BuildDRBSetup
2076  *
2077  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2078  *
2079  * @return void
2080  *
2081  * ****************************************************************/
2082 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2083 {
2084    DRBs_ToBeSetup_Item_t *drbSetItem;
2085    uint8_t  flowidx;
2086    uint8_t  drbidx;
2087    if(drbSet->list.array == NULLP)
2088    {
2089       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
2090       {
2091          if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
2092          {
2093             drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
2094             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
2095             {
2096                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2097                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
2098                {
2099                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2100                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2101                   {
2102                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2103                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2104                      {
2105                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
2106                         {
2107                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
2108                            {
2109                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
2110                               {
2111                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2112                                        flows_Mapped_To_DRB_List.list.array != NULLP)
2113                                  {
2114                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2115                                           flows_Mapped_To_DRB_List.list.count; flowidx++)
2116                                     {
2117                                        if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2118                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2119                                        {
2120                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2121                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2122                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
2123                                           {
2124                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2125                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2126                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2127                                              {
2128                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2129                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2130                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2131                                                 {
2132                                                    FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2133                                                    CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2134
2135                                                    CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2136                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2137                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2138                                                          sizeof(MaxDataBurstVolume_t));
2139                                                 }
2140                                                 CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2141                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2142                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2143                                              }
2144                                              CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2145                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2146                                                    qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2147                                           }
2148                                        }
2149                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2150                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2151                                        {
2152                                           CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2153                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
2154                                        }
2155                                     }
2156                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2157                                           flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
2158                                           choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
2159                                  }
2160                                  CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
2161                                        drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
2162                               }
2163                               CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
2164                                     sizeof(OCTET_STRING_t));
2165                            }
2166                            CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
2167                                  drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
2168                         }
2169                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2170                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
2171                      }
2172                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2173                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2174                   }
2175                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2176                         qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
2177                }
2178                CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2179             }
2180          }
2181          if(drbSet->list.array[drbidx]!=NULLP)
2182          {
2183             CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2184          }
2185       }
2186       CU_FREE(drbSet->list.array,drbSet->list.size);
2187    }
2188 }
2189
2190
2191 /*******************************************************************
2192  *
2193  * @brief Free the UE Setup Request
2194  *
2195  * @details
2196  *
2197  *    Function : FreeUESetReq
2198  *
2199  *    Functionality: Deallocate the memory of BuildUESetReq
2200  *
2201  * @params[in]  F1AP_PDU_t  *f1apMsg
2202  *
2203  * @return void
2204  *
2205  *
2206  * ****************************************************************/
2207 void FreeUESetReq(F1AP_PDU_t  *f1apMsg)
2208 {
2209    uint8_t idx=2;
2210    uint8_t ieId;
2211    UEContextSetupRequest_t       *ueSetReq;
2212
2213    if(f1apMsg != NULLP)
2214    {
2215       if(f1apMsg->choice.initiatingMessage != NULLP)
2216       {
2217          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2218          if(ueSetReq->protocolIEs.list.array != NULLP)
2219          {
2220             if(ueSetReq->protocolIEs.list.array[idx])
2221             {
2222                FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2223                idx=6;
2224                if(ueSetReq->protocolIEs.list.array[idx])
2225                {
2226                   FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2227                   idx++;
2228                   if(ueSetReq->protocolIEs.list.array[idx])
2229                   {
2230                      FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2231                      idx++;
2232                      if(ueSetReq->protocolIEs.list.array[idx])
2233                      {
2234                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2235                      }
2236                   }
2237                }
2238             }
2239             for(ieId=0; ieId<ueSetReq->protocolIEs.list.count; ieId++)
2240             {
2241                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
2242                {
2243                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
2244                }
2245             }
2246             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2247          }
2248          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2249       }
2250       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2251    }
2252 }
2253
2254 /*******************************************************************
2255  *
2256  * @brief Builds and sends the UE Setup Request
2257  *
2258  * @details
2259  *
2260  *    Function : BuildAndSendUESetReq
2261  *
2262  *    Functionality: Constructs the UE Setup Request and sends
2263  *                   it to the CU through SCTP.
2264  *
2265  * @params[in]
2266  *
2267  * @return ROK     - success
2268  *         RFAILED - failure
2269  *
2270  * ****************************************************************/
2271 uint8_t BuildAndSendUESetReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
2272    uint16_t rrcContLen, uint8_t *rrcContainer)
2273 {
2274    uint8_t   Nrcgiret;
2275    uint8_t   SplCellListret;
2276    uint8_t   SrbSetupret;
2277    uint8_t   elementCnt;
2278    uint8_t   idx;
2279    uint8_t   idx1;
2280    F1AP_PDU_t           *f1apMsg = NULLP;
2281    UEContextSetupRequest_t *ueSetReq = NULLP;
2282    asn_enc_rval_t encRetVal;        /* Encoder return value */
2283    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2284    uint8_t ret= RFAILED;
2285    uint8_t ret1;
2286    while(true)
2287    {
2288       DU_LOG("\n F1AP : Building UE Context Setup Request\n");
2289
2290       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2291       if(f1apMsg == NULLP)
2292       {
2293          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
2294          break;
2295       }
2296
2297       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2298       CU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2299       if(f1apMsg->choice.initiatingMessage == NULLP)
2300       {
2301          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
2302          break;
2303       }
2304
2305       f1apMsg->choice.initiatingMessage->procedureCode = \
2306          ProcedureCode_id_UEContextSetup;
2307       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
2308       f1apMsg->choice.initiatingMessage->value.present = \
2309          InitiatingMessage__value_PR_UEContextSetupRequest;
2310       ueSetReq =
2311          &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2312
2313       elementCnt = 11;
2314       ueSetReq->protocolIEs.list.count = elementCnt;
2315       ueSetReq->protocolIEs.list.size = \
2316                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
2317
2318       /* Initialize the UESetup members */
2319       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2320
2321       if(ueSetReq->protocolIEs.list.array == NULLP)
2322       {
2323          DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
2324          break;
2325       }
2326
2327       for(idx1=0; idx1<elementCnt; idx1++)
2328       {
2329          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
2330          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
2331          {
2332             break;
2333          }
2334       }
2335
2336       idx = 0;
2337
2338       /*GNB CU UE F1AP ID*/
2339       ueSetReq->protocolIEs.list.array[idx]->id = \
2340                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2341       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2342       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2343                                                              UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
2344       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
2345
2346       /*GNB DU UE F1AP ID*/
2347       idx++;
2348       ueSetReq->protocolIEs.list.array[idx]->id = \
2349                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2350       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2351       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2352                                                              UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
2353       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
2354
2355       /*Special Cell ID*/
2356       idx++;
2357       ueSetReq->protocolIEs.list.array[idx]->id = \
2358                                                   ProtocolIE_ID_id_SpCell_ID;
2359       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2360       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2361                                                              UEContextSetupRequestIEs__value_PR_NRCGI;
2362       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2363       if(Nrcgiret != ROK)
2364       {
2365          break;
2366       }
2367
2368       /*Served Cell Index*/
2369       idx++;
2370       ueSetReq->protocolIEs.list.array[idx]->id = \
2371                                                   ProtocolIE_ID_id_ServCellIndex;
2372       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2373       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2374                                                              UEContextSetupRequestIEs__value_PR_ServCellIndex;
2375       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
2376                                                                           CELL_INDEX;
2377
2378       /*CellULConfigured*/
2379       idx++;
2380       ueSetReq->protocolIEs.list.array[idx]->id = \
2381                                                   ProtocolIE_ID_id_SpCellULConfigured;
2382       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2383       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2384                                                              UEContextSetupRequestIEs__value_PR_CellULConfigured;
2385       ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
2386                                                                              CellULConfigured_none;
2387
2388
2389       /*CUtoDURRCContainer*/
2390       idx++;
2391       ueSetReq->protocolIEs.list.array[idx]->id = \
2392                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
2393       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2394       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2395                                                              UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
2396
2397       /*Special Cells to be SetupList*/
2398       idx++;
2399       ueSetReq->protocolIEs.list.array[idx]->id = \
2400                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
2401       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2402       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2403                                                              UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
2404       SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2405       if(SplCellListret != ROK)
2406       {
2407          break;
2408       }
2409       /*SRBs To Be Setup List*/
2410       idx++;
2411       ueSetReq->protocolIEs.list.array[idx]->id = \
2412                                                   ProtocolIE_ID_id_SRBs_ToBeSetup_List;
2413       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2414       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2415                                                              UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
2416       SrbSetupret =     BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2417       if(SrbSetupret != ROK)
2418       {
2419          break;
2420       }
2421       /*DRBs to Be Setup List*/
2422       idx++;
2423       ueSetReq->protocolIEs.list.array[idx]->id = \
2424                                                   ProtocolIE_ID_id_DRBs_ToBeSetup_List;
2425       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2426       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2427                                                              UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
2428       ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2429       if(ret1 != ROK)
2430       {
2431          break;
2432       }
2433
2434       /* RRC Container */
2435       idx++;
2436       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
2437       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
2438       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2439          UEContextSetupRequestIEs__value_PR_RRCContainer;
2440       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = rrcContLen;
2441       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
2442           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2443       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
2444       {
2445          DU_LOG(" F1AP : Memory allocation for BuildAndSendUESetReq failed");
2446          break;
2447       }
2448       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
2449          rrcContainer, ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2450
2451       /* RRC delivery status request */
2452       idx++;
2453       ueSetReq->protocolIEs.list.array[idx]->id = \
2454          ProtocolIE_ID_id_RRCDeliveryStatusRequest;
2455       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
2456       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2457          UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
2458       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
2459          RRCDeliveryStatusRequest_true;
2460
2461       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2462
2463       /* Encode the F1SetupRequest type as APER */
2464       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2465       encBufSize = 0;
2466       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2467             encBuf);
2468       /* Encode results */
2469       if(encRetVal.encoded == ENCODE_FAIL)
2470       {
2471          DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
2472                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2473          break;
2474       }
2475       else
2476       {
2477          DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
2478          for(int i=0; i< encBufSize; i++)
2479          {
2480             printf("%x",encBuf[i]);
2481          }
2482       }
2483
2484       /* Sending  msg  */
2485       if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)    !=      ROK)
2486       {
2487          DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
2488          break;
2489       }
2490       ret = ROK;
2491       break;
2492    }
2493    FreeUESetReq(f1apMsg);
2494
2495    return ret;
2496 }/* End of BuildAndSendUESetReq*/
2497
2498 uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
2499 {
2500    uint8_t idx;
2501    uint8_t ret =ROK;
2502    uint8_t cuUeF1apId, duUeF1apId;
2503    uint8_t *rrcContainer;
2504    uint16_t rrcContLen;
2505    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
2506
2507    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2508
2509    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
2510    {
2511       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
2512       {
2513          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
2514             {
2515                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
2516                break;
2517             }
2518          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2519             {
2520                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2521                break;
2522             }
2523          case ProtocolIE_ID_id_SRBID:
2524             break;
2525          case ProtocolIE_ID_id_RRCContainer:
2526             {
2527                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
2528                CU_ALLOC(rrcContainer, rrcContLen)
2529                if(!rrcContainer)
2530                {
2531                   DU_LOG("\nCU_STUB: Failed to allocated memory in procUlRrcMsg");
2532                   return RFAILED;
2533                }
2534                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
2535                      rrcContLen);
2536                break;
2537             }
2538
2539          default:
2540             DU_LOG("\n Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
2541             break;
2542       }
2543    }
2544    if(!ret)
2545       ret = BuildAndSendUESetReq(cuUeF1apId, duUeF1apId, rrcContLen, rrcContainer);
2546    return ret;
2547 }
2548 /****************************************************************
2549  * @brief Build And Send F1ResetAck
2550  *
2551  * @details
2552  *
2553  *    Function : FreeF1ResetAck
2554  *
2555  *    Functionality:
2556  *         - Build And Send  F1ResetRSP
2557  *
2558  *  @params[in]
2559  * @return ROK     - success
2560  *         RFAILED - failure
2561  *
2562  * ****************************************************************/
2563 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
2564 {
2565     uint8_t idx;
2566     ResetAcknowledge_t *f1ResetAck;
2567
2568     if(f1apMsg)
2569     {
2570        if(f1apMsg->choice.successfulOutcome)
2571        {
2572           f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
2573
2574           if(f1ResetAck->protocolIEs.list.array)
2575           {
2576              for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
2577              {
2578                 if(f1ResetAck->protocolIEs.list.array[idx])
2579                 {
2580                    CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
2581                 }
2582              }
2583              CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
2584           }
2585           CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
2586        }
2587        CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2588     }
2589 }
2590 /****************************************************************
2591 * @brief Build And Send F1ResetAck
2592 *
2593 * @details
2594 *
2595 *    Function : BuildAndSendF1ResetAck
2596 *
2597 *    Functionality:
2598 *         - Build And Send  F1ResetRSP
2599 *
2600 *  @params[in]
2601 * @return ROK     - success
2602 *         RFAILED - failure
2603 *
2604 * ****************************************************************/
2605
2606 uint8_t BuildAndSendF1ResetAck()
2607 {
2608    uint8_t                idx = 0;
2609    uint8_t                elementCnt = 0;
2610    uint8_t                ret = RFAILED;
2611    F1AP_PDU_t             *f1apMsg = NULL;
2612    ResetAcknowledge_t     *f1ResetAck = NULLP;
2613    asn_enc_rval_t         encRetVal;
2614    DU_LOG("\nF1AP : Building F1 Reset Acknowledgment \n");
2615
2616    do{
2617         /* Allocate the memory for F1ResetRequest_t */
2618         CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2619         if(f1apMsg == NULLP)
2620         {
2621            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
2622            break;
2623         }
2624
2625         f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
2626
2627         CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
2628         if(f1apMsg->choice.successfulOutcome == NULLP)
2629         {
2630            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
2631            break;
2632         }
2633
2634         f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
2635         f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
2636         f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
2637         f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
2638
2639         elementCnt = 1;
2640
2641         f1ResetAck->protocolIEs.list.count = elementCnt;
2642         f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
2643
2644         CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
2645         if(f1ResetAck->protocolIEs.list.array == NULLP)
2646         {
2647            DU_LOG("\nF1AP : Memory allocation for F1ResetAckIEs failed");
2648            break;
2649         }
2650
2651         for(idx=0; idx<elementCnt; idx++)
2652         {
2653            CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
2654            if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
2655            {
2656               break;
2657            }
2658         }
2659         /*TransactionID*/
2660         idx = 0;
2661         f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
2662         f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
2663         f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
2664         f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
2665
2666         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2667
2668         /* Encode the F1SetupRequest type as UPER */
2669         memset(encBuf, 0, ENC_BUF_MAX_LEN);
2670         encBufSize = 0;
2671         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
2672
2673         /* Check encode results */
2674         if(encRetVal.encoded == ENCODE_FAIL)
2675         {
2676            DU_LOG("\nF1AP : Could not encode F1ResetAck structure (at %s)\n",\
2677                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2678            break;
2679         }
2680         else
2681         {
2682            DU_LOG("\nF1AP : Created APER encoded buffer for F1ResetAck \n");
2683            for(int i=0; i< encBufSize; i++)
2684            {
2685               printf("%x",encBuf[i]);
2686            }
2687         }
2688         /* Sending msg */
2689         if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
2690         {
2691            DU_LOG("\nF1AP : Sending F1 Reset Response failed");
2692            break;
2693         }
2694
2695         ret = ROK;
2696         break;
2697    }while(true);
2698
2699    FreeF1ResetAck(f1apMsg);
2700    return ret;
2701 }
2702 /*******************************************************************
2703  *
2704  * @brief Handles received F1AP message and sends back response
2705  *
2706  * @details
2707  *
2708  *    Function : F1APMsgHdlr
2709  *
2710  *    Functionality:
2711  *         - Decodes received F1AP control message
2712  *         - Prepares response message, encodes and sends to SCTP
2713  *
2714  * @params[in]
2715  * @return ROK     - success
2716  *         RFAILED - failure
2717  *
2718  * ****************************************************************/
2719 void F1APMsgHdlr(Buffer *mBuf)
2720 {
2721    int i;
2722    char *recvBuf;
2723    MsgLen copyCnt;
2724    MsgLen recvBufLen;
2725    F1AP_PDU_t *f1apMsg = NULLP;
2726    asn_dec_rval_t rval; /* Decoder return value */
2727    F1AP_PDU_t f1apasnmsg ;
2728
2729    DU_LOG("\nF1AP : Received F1AP message buffer");
2730    ODU_PRINT_MSG(mBuf, 0,0);
2731
2732    /* Copy mBuf into char array to decode it */
2733    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
2734    CU_ALLOC(recvBuf, (Size)recvBufLen);
2735
2736    if(recvBuf == NULLP)
2737    {
2738       DU_LOG("\nF1AP : Memory allocation failed");
2739       return;
2740    }
2741    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
2742    {
2743       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
2744       return;
2745    }
2746
2747    printf("\nF1AP : Received flat buffer to be decoded : ");
2748    for(i=0; i< recvBufLen; i++)
2749    {
2750       printf("%x",recvBuf[i]);
2751    }
2752
2753    /* Decoding flat buffer into F1AP messsage */
2754    f1apMsg = &f1apasnmsg;
2755    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
2756
2757    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
2758    CU_FREE(recvBuf, (Size)recvBufLen);
2759
2760    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2761    {
2762       DU_LOG("\nF1AP : ASN decode failed");
2763       return;
2764    }
2765    printf("\n");
2766    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2767
2768    switch(f1apMsg->present)
2769    {
2770       case F1AP_PDU_PR_initiatingMessage:
2771       {
2772          switch(f1apMsg->choice.initiatingMessage->value.present)
2773          {
2774             case InitiatingMessage__value_PR_Reset:
2775             {
2776                 DU_LOG("\nF1AP : F1 reset request received ");
2777                 BuildAndSendF1ResetAck();
2778                 break;
2779             }
2780
2781             case InitiatingMessage__value_PR_F1SetupRequest:
2782             {
2783                DU_LOG("\nF1AP : F1 setup request received");
2784                BuildAndSendF1SetupRsp();
2785                break;
2786             }
2787
2788             case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
2789             {
2790                DU_LOG("\nF1AP : GNB-DU config update received");
2791                BuildAndSendDUUpdateAck();
2792                DU_LOG("\nF1AP : Sending F1 reset request");
2793                BuildAndSendF1ResetReq();
2794                break;
2795             }
2796             case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
2797             {
2798                DU_LOG("\nF1AP : Received InitialULRRCMessageTransfer");
2799                procInitULRRCMsg(f1apMsg);
2800                break;
2801             }
2802             case InitiatingMessage__value_PR_ULRRCMessageTransfer:
2803             {
2804                DU_LOG("\nF1AP : Received ULRRCMessageTransfer");
2805                procUlRrcMsg(f1apMsg);
2806                break;
2807             }
2808
2809             case InitiatingMessage__value_PR_RRCDeliveryReport:
2810             {
2811                DU_LOG("\nF1AP : Received RRC delivery report");
2812                 break;
2813             }
2814             default:
2815             {
2816                DU_LOG("\nF1AP : Invalid type of intiating message [%d]",f1apMsg->choice.initiatingMessage->value.present);
2817                return;
2818             }
2819          }/* End of switch(initiatingMessage) */
2820          break;
2821       }
2822
2823       case F1AP_PDU_PR_successfulOutcome:
2824       {
2825          switch(f1apMsg->choice.successfulOutcome->value.present)
2826          {
2827             case SuccessfulOutcome__value_PR_ResetAcknowledge:
2828             {
2829                DU_LOG("\nF1Reset Acknowledgement is received successfully ");
2830                break;
2831             }
2832          }/* End of switch(successfulOutcome) */
2833          break;
2834       }
2835       default:
2836          {
2837             DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
2838             return;
2839          }
2840    }/* End of switch(f1apMsg->present) */
2841
2842 } /* End of F1APMsgHdlr */
2843
2844 /**********************************************************************
2845   End of file
2846  **********************************************************************/