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
  21 #include "cu_stub_sctp.h"
  22 #include "cu_f1ap_msg_hdl.h"
  23
  24 /*******************************************************************
  25 *
  26 * @brief Sends F1 msg over SCTP
  27 *
  28 * @details
  29 *
  30 *    Function : SendF1APMsg
  31 *
  32 *    Functionality: Sends F1 msg over SCTP
  33 *
  34 * @params[in] Region region
  35 *             Pool pool
  36 * @return ROK     - success
  37 *         RFAILED - failure
  38 *
  39 * ****************************************************************/
  40 S16 SendF1APMsg(Region region, Pool pool)
  41 {
  42    Buffer *mBuf;
  43
  44    if(SGetMsg(region, pool, &mBuf) == ROK)
  45    {
  46       if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
  47       {
  48          SPrntMsg(mBuf, 0,0);
  49
  50          if(sctpSend(mBuf) != ROK)
  51          {
  52             DU_LOG("\nF1AP : SCTP Send failed");
  53             SPutMsg(mBuf);
  54             RETVALUE(RFAILED);
  55          }
  56       }
  57       else
  58       {
  59          DU_LOG("\nF1AP : SAddPstMsgMult failed");
  60          SPutMsg(mBuf);
  61          RETVALUE(RFAILED);
  62       }
  63       SPutMsg(mBuf);
  64    }
  65    else
  66    {
  67       DU_LOG("\nF1AP : Failed to allocate memory");
  68       RETVALUE(RFAILED);
  69    }
  70
  71    RETVALUE(ROK);
  72 } /* SendF1APMsg */
  73
  74 /*******************************************************************
  75 *
  76 * @brief Builds NRCell ID
  77 *
  78 * @details
  79 *
  80 *    Function : BuildNrCellId
  81 *
  82 *    Functionality: Building the NR Cell ID
  83 *
  84 * @params[in] BIT_STRING_t *nrcell
  85 * @return ROK     - success
  86 *         RFAILED - failure
  87 *
  88 * ****************************************************************/
  89
  90 S16 BuildNrCellId(BIT_STRING_t *nrcell)
  91 {
  92    U8 tmp;
  93    for (tmp = 0 ; tmp < nrcell->size-1; tmp++)
  94    {
  95       nrcell->buf[tmp] = 0;
  96    }
  97    nrcell->buf[4]   = 16;
  98    nrcell->bits_unused = 4;
  99    nrcell->size = 5 * sizeof(uint8_t);
 100    RETVALUE(ROK);
 101 }
 102
 103 /********************************************************************
 104  *
 105  * @brief Builds and sends the F1SetupResponse
 106  *
 107  * @details
 108  *
 109  *    Function : BuildAndSendF1SetupRsp
 110  *
 111  *    Functionality: Constructs the F1SetupResponse message and sends
 112  *                   it back to the DU through SCTP.
 113  *
 114  * @params[in] void **buf,Buffer to which encoded pattern is written into
 115  * @params[in] int *size,size of buffer
 116  *
 117  * @return ROK     - success
 118  *         RFAILED - failure
 119  *
 120  * ****************************************************************/
 121 S16 BuildAndSendF1SetupRsp()
 122 {
 123    U8    idx,idy;
 124    U8    elementCnt,cellCnt;
 125    F1AP_PDU_t         *f1apMsg = NULL;
 126    F1SetupResponse_t  *f1SetupRsp;
 127    GNB_CU_Name_t      *cuName;
 128    Cells_to_be_Activated_List_t *cellToActivate;
 129         RRC_Version_t      *rrcVer;
 130         asn_enc_rval_t     encRetVal;
 131         DU_LOG("\nF1AP : Building F1 Setup Response\n");
 132
 133    /* Allocate the memory for F1SetupRequest_t */
 134    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 135    if(f1apMsg == NULLP)
 136    {
 137       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 138       RETVALUE(RFAILED);
 139    }
 140    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 141
 142    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 143    if(f1apMsg->choice.successfulOutcome == NULLP)
 144    {
 145       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 146       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 147       RETVALUE(RFAILED);
 148    }
 149
 150    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 151    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 152    f1apMsg->choice.successfulOutcome->value.present = \
 153          SuccessfulOutcome__value_PR_F1SetupResponse;
 154    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 155
 156    elementCnt = 4;
 157    f1SetupRsp->protocolIEs.list.count = elementCnt;
 158    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 159
 160    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 161          elementCnt * sizeof(F1SetupResponseIEs_t *));
 162    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 163    {
 164       DU_LOG("\nF1AP : Memory allocation for F1ResponseIEs failed");
 165       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 166       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 167       RETVALUE(RFAILED);
 168    }
 169
 170    for(idx=0; idx<elementCnt; idx++)
 171    {
 172       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 173             sizeof(F1SetupResponseIEs_t));
 174       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 175       {
 176          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 177                elementCnt * sizeof(F1SetupResponseIEs_t *));
 178          CU_FREE(f1apMsg->choice.successfulOutcome, \
 179                sizeof(SuccessfulOutcome_t));
 180          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 181          RETVALUE(RFAILED);
 182       }
 183    }
 184
 185    /*TransactionID*/
 186    idx = 0;
 187    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 188    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 189    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 190                                      F1SetupResponseIEs__value_PR_TransactionID;
 191    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 192                                                                        TRANS_ID;
 193
 194    /*CU Name*/
 195    idx++;
 196    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 197    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 198    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 199                                        F1SetupResponseIEs__value_PR_GNB_CU_Name;
 200    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 201    cuName->size = sizeof(cuCfgParams.cuName);
 202
 203    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 204    if(cuName->buf == NULLP)
 205       {
 206          for(idy=0; idy<elementCnt; idy++)
 207          {
 208             CU_FREE(f1SetupRsp->protocolIEs.list.array[idy],\
 209                   sizeof(F1SetupResponseIEs_t));
 210          }
 211          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 212                elementCnt * sizeof(F1SetupResponseIEs_t *));
 213          CU_FREE(f1apMsg->choice.successfulOutcome,\
 214                sizeof(SuccessfulOutcome_t));
 215          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 216          RETVALUE(RFAILED);
 217       }
 218    strcpy((char*)cuName->buf, (char*)cuCfgParams.cuName);
 219
 220    /*Cells to be activated list*/
 221    idx++;
 222    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 223                               ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 224    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 225    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 226                      F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 227    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 228                     Cells_to_be_Activated_List;
 229    cellCnt=1;
 230    cellToActivate->list.count = cellCnt;
 231    cellToActivate->list.size = \
 232                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 233    CU_ALLOC(cellToActivate->list.array,\
 234          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 235    if(cellToActivate->list.array == NULLP)
 236    {
 237       CU_FREE(cuName->buf, sizeof(cuName->size));
 238       for(idy=0; idy<elementCnt; idy++)
 239       {
 240          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy],\
 241                sizeof(F1SetupResponseIEs_t));
 242       }
 243       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 244             elementCnt * sizeof(F1SetupResponseIEs_t *));
 245       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 246       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 247       RETVALUE(RFAILED);
 248    }
 249    for(idy=0; idy<cellCnt; idy++)
 250    {
 251       CU_ALLOC(cellToActivate->list.array[idy],\
 252             sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 253       if(cellToActivate->list.array[idy] == NULLP)
 254       {
 255          CU_FREE(cellToActivate->list.array,\
 256                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 257          CU_FREE(cuName->buf, sizeof(cuName->size));
 258          for(idy=0; idy<elementCnt; idy++)
 259          {
 260             CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 261                   sizeof(F1SetupResponseIEs_t));
 262          }
 263          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 264                elementCnt * sizeof(F1SetupResponseIEs_t *));
 265          CU_FREE(f1apMsg->choice.successfulOutcome, \
 266                sizeof(SuccessfulOutcome_t));
 267          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 268          RETVALUE(RFAILED);
 269       }
 270    }
 271    cellToActivate->list.array[0]->id = \
 272                               ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 273    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 274    cellToActivate->list.array[0]->value.present = \
 275        Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 276    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 277       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 278    CU_ALLOC(cellToActivate->list.array[0]->\
 279          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 280          3*sizeof(uint8_t));
 281    if(cellToActivate->list.array[0]->value.choice.\
 282          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 283    {
 284
 285       for(idy=0; idy<cellCnt; idy++)
 286       {
 287          CU_FREE(cellToActivate->list.array[idy],\
 288                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 289       }
 290
 291       CU_FREE(cellToActivate->list.array,\
 292             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 293       CU_FREE(cuName->buf, sizeof(cuName->size));
 294       for(idy=0; idy<elementCnt; idy++)
 295       {
 296          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 297                sizeof(F1SetupResponseIEs_t));
 298       }
 299       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 300             elementCnt * sizeof(F1SetupResponseIEs_t *));
 301       CU_FREE(f1apMsg->choice.successfulOutcome, \
 302             sizeof(SuccessfulOutcome_t));
 303       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 304       RETVALUE(RFAILED);
 305    }
 306     buildPlmnId(cuCfgParams.plmn , &cellToActivate->list.array[0]->value.choice.\
 307          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity);
 308    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 309       nRCGI.nRCellIdentity.size = 5;
 310    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 311          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 312          5*sizeof(uint8_t));
 313    if(cellToActivate->list.array[0]->value.choice.\
 314        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 315    {
 316       CU_FREE(cellToActivate->list.array[0]->\
 317           value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 318           3*sizeof(uint8_t));
 319       for(idy=0; idy<cellCnt; idy++)
 320       {
 321          CU_FREE(cellToActivate->list.array[idy],\
 322                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 323       }
 324
 325       CU_FREE(cellToActivate->list.array,\
 326             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 327       CU_FREE(cuName->buf, sizeof(cuName->size));
 328       for(idy=0; idy<elementCnt; idy++)
 329       {
 330          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 331                sizeof(F1SetupResponseIEs_t));
 332       }
 333       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 334             elementCnt * sizeof(F1SetupResponseIEs_t *));
 335       CU_FREE(f1apMsg->choice.successfulOutcome, \
 336             sizeof(SuccessfulOutcome_t));
 337       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 338       RETVALUE(RFAILED);
 339    }
 340    BuildNrCellId(&(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity));
 341    /* RRC Version */
 342    idx++;
 343    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 344                                         ProtocolIE_ID_id_GNB_CU_RRC_Version;
 345    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 346    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 347                                     F1SetupResponseIEs__value_PR_RRC_Version;
 348    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 349    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 350
 351    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 352    if(rrcVer->latest_RRC_Version.buf == NULLP)
 353    {
 354       CU_FREE(cuName->buf, sizeof(cuName->size));
 355       for(idy=0; idy<elementCnt; idx++)
 356       {
 357          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 358                sizeof(F1SetupResponseIEs_t));
 359       }
 360       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 361             elementCnt * sizeof(F1SetupResponseIEs_t *));
 362       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 363       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 364       RETVALUE(RFAILED);
 365    }
 366
 367   /* Need to check RRC Version */
 368    rrcVer->latest_RRC_Version.buf[0] = cuCfgParams.rrcVersion.rrcVer;
 369    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 370    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 371    if(rrcVer->iE_Extensions == NULLP)
 372    {
 373       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 374       CU_FREE(cuName->buf, sizeof(cuName->size));
 375       for(idy=0; idy<elementCnt; idy++)
 376       {
 377          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 378                sizeof(F1SetupResponseIEs_t));
 379       }
 380       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 381             elementCnt * sizeof(F1SetupResponseIEs_t *));
 382       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 383       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 384       RETVALUE(RFAILED);
 385    }
 386    rrcVer->iE_Extensions->list.count = 1;
 387    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 388    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 389          sizeof(struct RRC_Version_ExtIEs *));
 390    if(rrcVer->iE_Extensions->list.array == NULLP)
 391    {
 392       CU_FREE(rrcVer->iE_Extensions,\
 393             sizeof(ProtocolExtensionContainer_4624P81_t));
 394       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 395       CU_FREE(cuName->buf, sizeof(cuName->size));
 396       for(idy=0; idy<elementCnt; idy++)
 397       {
 398          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 399                sizeof(F1SetupResponseIEs_t));
 400       }
 401       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 402             elementCnt * sizeof(F1SetupResponseIEs_t *));
 403       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 404       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 405       RETVALUE(RFAILED);
 406    }
 407    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 408          sizeof(struct RRC_Version_ExtIEs));
 409    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 410    {
 411       CU_FREE(rrcVer->iE_Extensions->list.array,\
 412             sizeof(struct RRC_Version_ExtIEs *));
 413       CU_FREE(rrcVer->iE_Extensions,\
 414             sizeof(ProtocolExtensionContainer_4624P81_t));
 415       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 416       CU_FREE(cuName->buf, sizeof(cuName->size));
 417       for(idy=0; idy<elementCnt; idy++)
 418       {
 419          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 420                sizeof(F1SetupResponseIEs_t));
 421       }
 422       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 423             elementCnt * sizeof(F1SetupResponseIEs_t *));
 424       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 425       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 426       RETVALUE(RFAILED);
 427    }
 428    rrcVer->iE_Extensions->list.array[0]->id = \
 429                                 ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 430    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 431    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 432              RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 433    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 434       Latest_RRC_Version_Enhanced.size = 3*sizeof(U8);
 435    CU_ALLOC(rrcVer->iE_Extensions->list.\
 436          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 437          3*sizeof(U8));
 438    if(rrcVer->iE_Extensions->list.\
 439       array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 440    {
 441       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 442              sizeof(struct RRC_Version_ExtIEs));
 443       CU_FREE(rrcVer->iE_Extensions->list.array,\
 444             sizeof(struct RRC_Version_ExtIEs *));
 445       CU_FREE(rrcVer->iE_Extensions,\
 446             sizeof(ProtocolExtensionContainer_4624P81_t));
 447       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 448       CU_FREE(cuName->buf, sizeof(cuName->size));
 449       for(idy=0; idy<elementCnt; idy++)
 450       {
 451          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 452                sizeof(F1SetupResponseIEs_t));
 453       }
 454       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 455             elementCnt * sizeof(F1SetupResponseIEs_t *));
 456       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 457       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 458       RETVALUE(RFAILED);
 459    }
 460    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 461       Latest_RRC_Version_Enhanced.buf[0] = 0;
 462    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 463       Latest_RRC_Version_Enhanced.buf[1] = 5;
 464    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 465       Latest_RRC_Version_Enhanced.buf[2] = 15;
 466
 467    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 468
 469    /* Encode the F1SetupRequest type as UPER */
 470    cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
 471    encBufSize = 0;
 472    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 473
 474    /* Clean up */
 475    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 476    CU_FREE(cuName->buf, sizeof(cuName->size));
 477    for(idx=0; idx<elementCnt; idx++)
 478    {
 479       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 480    }
 481    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 482    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 483    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 484
 485    /* Check encode results */
 486    if(encRetVal.encoded == ENCODE_FAIL)
 487    {
 488            DU_LOG("\nF1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 489                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 490            RETVALUE(RFAILED);
 491    }
 492    else
 493    {
 494            DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupResponse\n");
 495            for(int i=0; i< encBufSize; i++)
 496            {
 497                    printf("%x",encBuf[i]);
 498            }
 499    }
 500
 501    /* Sending msg */
 502    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 503    {
 504            DU_LOG("\nF1AP : Sending F1 Setup Response failed");
 505            RETVALUE(RFAILED);
 506    }
 507
 508    RETVALUE(ROK);
 509 }/* End of BuildAndSendF1SetupRsp */
 510
 511 /*******************************************************************
 512  *
 513  * @brief Builds and sends the DUUpdateAcknowledge
 514  *
 515  * @details
 516  *
 517  *    Function : BuildAndSendDUUpdateAck
 518  *
 519  *    Functionality: Constructs the DU Update Acknowledge message and sends
 520  *                   it to the DU through SCTP.
 521  *
 522  * @params[in] void **buf,Buffer to which encoded pattern is written into
 523  * @params[in] int *size,size of buffer
 524  *
 525  * @return ROK     - success
 526  *         RFAILED - failure
 527  *
 528  * ****************************************************************/
 529
 530 S16 BuildAndSendDUUpdateAck()
 531 {
 532    U8   idx;
 533    U8   elementCnt;
 534    F1AP_PDU_t *f1apMsg = NULL;
 535    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 536    asn_enc_rval_t enRetVal; /* Encoder return value */
 537
 538    DU_LOG("\nF1AP : Building GNB-DU Config Update Ack\n");
 539
 540    /* Allocate the memory for F1SetupRequest_t */
 541    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 542    if(f1apMsg == NULLP)
 543    {
 544       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 545       RETVALUE(RFAILED);
 546    }
 547
 548    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 549
 550    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 551    if(f1apMsg->choice.successfulOutcome == NULLP)
 552    {
 553       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 554       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 555       RETVALUE(RFAILED);
 556    }
 557
 558    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 559    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 560    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 561    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 562
 563    elementCnt = 1;
 564    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 565    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 566
 567    /* Initialize the F1Setup members */
 568    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 569    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 570    {
 571       DU_LOG("\nF1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 572       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 573       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 574       RETVALUE(RFAILED);
 575    }
 576
 577    for(idx=0; idx<elementCnt; idx++)
 578    {
 579       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 580       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 581       {
 582          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 583          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 584          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 585          RETVALUE(RFAILED);
 586       }
 587    }
 588
 589    /*TransactionID*/
 590    idx = 0;
 591    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 592    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 593    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present = GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 594    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 595
 596    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 597
 598    /* Encode the F1SetupRequest type as UPER */
 599    cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
 600    encBufSize = 0;
 601    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 602
 603    /* Clean up */
 604    for(idx=0; idx<elementCnt; idx++)
 605    {
 606       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 607    }
 608    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 609    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 610    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 611
 612    /* Checking encode results */
 613    if(enRetVal.encoded == ENCODE_FAIL)
 614    {
 615       DU_LOG("\nF1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 616       RETVALUE(RFAILED);
 617    }
 618    else
 619    {
 620     DU_LOG("\nF1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 621       for(int i=0; i< encBufSize; i++)
 622       {
 623          printf("%x",encBuf[i]);
 624       }
 625    }
 626
 627    /* Sending msg */
 628    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 629    {
 630       DU_LOG("\nF1AP : Sending GNB-DU Config Update Ack failed");
 631       RETVALUE(RFAILED);
 632    }
 633
 634    RETVALUE(ROK);
 635
 636 }/* End of BuildAndSendDUUpdateAck*/
 637
 638 /*******************************************************************
 639  *
 640  * @brief Builds and sends the DLRRCMessageTransfer
 641  *
 642  * @details
 643  *
 644  *    Function : BuildAndSendDLRRCMessageTransfer
 645  *
 646  *    Functionality: Constructs the DL RRC Message Transfer and sends
 647  *                   it to the CU through SCTP.
 648  *
 649  * @params[in]
 650  *
 651  * @return ROK     - success
 652  *         RFAILED - failure
 653  *
 654  * ****************************************************************/
 655 S16 BuildAndSendDLRRCMessageTransfer()
 656 {
 657         S16  ret;
 658         U8   elementCnt;
 659         U8   ieId;
 660         U8   idx;
 661         F1AP_PDU_t                              *f1apMsg = NULL;
 662    DLRRCMessageTransfer_t       *dlRRCMsg;
 663         asn_enc_rval_t                          encRetVal;        /* Encoder return value */
 664
 665         DU_LOG("\n F1AP : Building DL RRC Message Transfer Message\n");
 666
 667         CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 668         if(f1apMsg == NULLP)
 669         {
 670                 DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
 671                 RETVALUE(RFAILED);
 672         }
 673
 674         f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 675         CU_ALLOC(f1apMsg->choice.initiatingMessage,
 676                         sizeof(InitiatingMessage_t));
 677         if(f1apMsg->choice.initiatingMessage == NULLP)
 678         {
 679                 DU_LOG(" F1AP : Memory allocation for   F1AP-PDU failed");
 680                 CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
 681                 RETVALUE(RFAILED);
 682         }
 683
 684         f1apMsg->choice.initiatingMessage->procedureCode = \
 685                                                                                                 ProcedureCode_id_DLRRCMessageTransfer;
 686         f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
 687         f1apMsg->choice.initiatingMessage->value.present = \
 688                                                                 InitiatingMessage__value_PR_DLRRCMessageTransfer;
 689         dlRRCMsg =
 690                 &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
 691         elementCnt = 3;
 692         dlRRCMsg->protocolIEs.list.count = elementCnt;
 693         dlRRCMsg->protocolIEs.list.size = \
 694                                                                         elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
 695
 696         /* Initialize the F1Setup members */
 697         CU_ALLOC(dlRRCMsg->protocolIEs.list.array, \
 698                         elementCnt * sizeof(DLRRCMessageTransferIEs_t *));
 699         if(dlRRCMsg->protocolIEs.list.array == NULLP)
 700         {
 701                 DU_LOG(" F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
 702                 CU_FREE(f1apMsg->choice.initiatingMessage,
 703                                 sizeof(InitiatingMessage_t));
 704                 CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 705                 RETVALUE(RFAILED);
 706         }
 707
 708         for(idx=0; idx<elementCnt; idx++)
 709         {
 710                 CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx],\
 711                                                                                 sizeof(DLRRCMessageTransferIEs_t));
 712                 if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
 713                 {
 714                         for(ieId=0; ieId<idx; ieId++)
 715                         {
 716                                 CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId],\
 717                                                 sizeof(DLRRCMessageTransferIEs_t));
 718                         }
 719                         CU_FREE(dlRRCMsg->protocolIEs.list.array,\
 720                                         elementCnt * sizeof(DLRRCMessageTransferIEs_t *));
 721                         CU_FREE(f1apMsg->choice.initiatingMessage,\
 722                                                                                                 sizeof(InitiatingMessage_t));
 723                         CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
 724                         RETVALUE(RFAILED);
 725                 }
 726         }
 727
 728         idx = 0;
 729
 730         /*GNB CU UE F1AP ID*/
 731         dlRRCMsg->protocolIEs.list.array[idx]->id       = \
 732                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
 733         dlRRCMsg->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
 734         dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
 735                                 DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
 736         dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
 737
 738         /*GNB DU UE F1AP ID*/
 739         idx++;
 740         dlRRCMsg->protocolIEs.list.array[idx]->id       = \
 741                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
 742         dlRRCMsg->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
 743         dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
 744                                 DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
 745         dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
 746
 747         /*SRBID*/
 748         idx++;
 749         dlRRCMsg->protocolIEs.list.array[idx]->id       = \
 750                                                                                                                  ProtocolIE_ID_id_SRBID;
 751         dlRRCMsg->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
 752         dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
 753                                                                 DLRRCMessageTransferIEs__value_PR_SRBID;
 754         dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = DL_SRBID;
 755
 756         /*RRCContainer*/
 757         //YET TO FILL
 758
 759         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 760
 761         /* Encode the F1SetupRequest type as APER */
 762         cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
 763         encBufSize = 0;
 764         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 765                         encBuf);
 766         /* Encode results */
 767         if(encRetVal.encoded == ENCODE_FAIL)
 768         {
 769                 DU_LOG( "\n F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
 770                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 771                 RETVALUE(RFAILED);
 772         }
 773         else
 774         {
 775                 DU_LOG("\n F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
 776                 for(int i=0; i< encBufSize; i++)
 777                 {
 778                         printf("%x",encBuf[i]);
 779                 }
 780         }
 781
 782         /* Sending  msg  */
 783         if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=      ROK)
 784         {
 785                 DU_LOG("\n F1AP : Sending       DL RRC Message Transfer Failed");
 786                 RETVALUE(RFAILED);
 787         }
 788
 789         RETVALUE(ROK);
 790 }/* End of BuildAndSendDLRRCMessageTransfer */
 791
 792
 793 /*******************************************************************
 794  *
 795  * @brief Builds and sends the UE Setup Response
 796  *
 797  * @details
 798  *
 799  *    Function : BuildAndSendUESetRsp
 800  *
 801  *    Functionality: Constructs the UE Setup Response and sends
 802  *                   it to the DU through SCTP.
 803  *
 804  * @params[in]
 805  *
 806  * @return ROK     - success
 807  *         RFAILED - failure
 808  *
 809  * ****************************************************************/
 810 S16 BuildAndSendUESetRsp()
 811 {
 812         S16  ret;
 813         U8   elementCnt;
 814         U8   cellCnt;
 815         U8   ieId;
 816         U8   idx;
 817         U8   drbCnt;
 818         U8   drbId;
 819         F1AP_PDU_t                                                      *f1apMsg = NULL;
 820    UEContextSetupResponse_t                     *ueSetRsp;
 821         asn_enc_rval_t                                                  encRetVal;        /* Encoder return value */
 822
 823         DU_LOG("\n F1AP : Building UE Context Setup Response\n");
 824
 825         CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 826         if(f1apMsg == NULLP)
 827         {
 828                 DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
 829                 RETVALUE(RFAILED);
 830         }
 831
 832         f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
 833         CU_ALLOC(f1apMsg->choice.successfulOutcome,
 834                         sizeof(SuccessfulOutcome_t));
 835         if(f1apMsg->choice.successfulOutcome == NULLP)
 836         {
 837                 DU_LOG(" F1AP : Memory allocation for   F1AP-PDU failed");
 838                 CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
 839                 RETVALUE(RFAILED);
 840         }
 841
 842         f1apMsg->choice.successfulOutcome->procedureCode = \
 843                                                                                                         ProcedureCode_id_UEContextSetup;
 844         f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 845         f1apMsg->choice.successfulOutcome->value.present = \
 846                                    SuccessfulOutcome__value_PR_UEContextSetupResponse;
 847         ueSetRsp =
 848                 &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
 849         elementCnt = 2;
 850         ueSetRsp->protocolIEs.list.count = elementCnt;
 851         ueSetRsp->protocolIEs.list.size = \
 852                                                                         elementCnt * sizeof(UEContextSetupResponse_t *);
 853
 854         /* Initialize the UESetup members */
 855         CU_ALLOC(ueSetRsp->protocolIEs.list.array, \
 856                                 ueSetRsp->protocolIEs.list.size);
 857         if(ueSetRsp->protocolIEs.list.array == NULLP)
 858         {
 859                 DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
 860                 CU_FREE(f1apMsg->choice.successfulOutcome,
 861                                 sizeof(SuccessfulOutcome_t));
 862                 CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 863                 RETVALUE(RFAILED);
 864         }
 865
 866         for(idx=0; idx<elementCnt; idx++)
 867         {
 868                 CU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
 869                                                                                 sizeof(UEContextSetupResponseIEs_t));
 870                 if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
 871                 {
 872                         for(ieId=0; ieId<idx; ieId++)
 873                         {
 874                                 CU_FREE(ueSetRsp->protocolIEs.list.array[ieId],\
 875                                                 sizeof(UEContextSetupResponseIEs_t));
 876                         }
 877                         CU_FREE(ueSetRsp->protocolIEs.list.array,\
 878                                                  ueSetRsp->protocolIEs.list.size);
 879                         CU_FREE(f1apMsg->choice.successfulOutcome,\
 880                                                                                                 sizeof(SuccessfulOutcome_t));
 881                         CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
 882                         RETVALUE(RFAILED);
 883                 }
 884         }
 885
 886         idx = 0;
 887
 888         /*GNB CU UE F1AP ID*/
 889         ueSetRsp->protocolIEs.list.array[idx]->id       = \
 890                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
 891         ueSetRsp->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
 892         ueSetRsp->protocolIEs.list.array[idx]->value.present = \
 893                                                 UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
 894         ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
 895
 896         /*GNB DU UE F1AP ID*/
 897         idx++;
 898         ueSetRsp->protocolIEs.list.array[idx]->id       = \
 899                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
 900         ueSetRsp->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
 901         ueSetRsp->protocolIEs.list.array[idx]->value.present = \
 902                                                 UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
 903         ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
 904
 905
 906         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 907
 908         /* Encode the F1SetupRequest type as APER */
 909         cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
 910         encBufSize = 0;
 911         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 912                         encBuf);
 913         /* Encode results */
 914         if(encRetVal.encoded == ENCODE_FAIL)
 915         {
 916                 DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
 917                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 918                 RETVALUE(RFAILED);
 919         }
 920         else
 921         {
 922                 DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
 923                 for(int i=0; i< encBufSize; i++)
 924                 {
 925                         printf("%x",encBuf[i]);
 926                 }
 927         }
 928
 929         /* Sending  msg  */
 930         if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=      ROK)
 931         {
 932                 DU_LOG("\n F1AP : Sending       UE Context Setup Request Failed");
 933                 RETVALUE(RFAILED);
 934         }
 935
 936         RETVALUE(ROK);
 937 }/* End of BuildAndSendUESetRsp */
 938 /*******************************************************************
 939 *
 940 * @brief Handles received F1AP message and sends back response
 941 *
 942 * @details
 943 *
 944 *    Function : F1APMsgHdlr
 945 *
 946 *    Functionality:
 947 *         - Decodes received F1AP control message
 948 *         - Prepares response message, encodes and sends to SCTP
 949 *
 950 * @params[in]
 951 * @return ROK     - success
 952 *         RFAILED - failure
 953 *
 954 * ****************************************************************/
 955 void F1APMsgHdlr(Buffer *mBuf)
 956 {
 957    int i;
 958    char *recvBuf;
 959    MsgLen copyCnt;
 960    MsgLen recvBufLen;
 961    F1AP_PDU_t *f1apMsg;
 962    asn_dec_rval_t rval; /* Decoder return value */
 963    F1AP_PDU_t f1apasnmsg ;
 964
 965    DU_LOG("\nF1AP : Received F1AP message buffer");
 966    SPrntMsg(mBuf, 0,0);
 967
 968    /* Copy mBuf into char array to decode it */
 969    SFndLenMsg(mBuf, &recvBufLen);
 970    if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
 971    {
 972       DU_LOG("\nF1AP : Memory allocation failed");
 973       return;
 974    }
 975    if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
 976    {
 977       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
 978       return;
 979    }
 980
 981    printf("\nF1AP : Received flat buffer to be decoded : ");
 982    for(i=0; i< recvBufLen; i++)
 983    {
 984         printf("%x",recvBuf[i]);
 985    }
 986
 987    /* Decoding flat buffer into F1AP messsage */
 988    f1apMsg = &f1apasnmsg;
 989    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
 990
 991    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
 992    SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
 993    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
 994    {
 995       DU_LOG("\nF1AP : ASN decode failed");
 996       return;
 997    }
 998    printf("\n");
 999    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1000
1001    switch(f1apMsg->present)
1002    {
1003       case F1AP_PDU_PR_initiatingMessage:
1004       {
1005          switch(f1apMsg->choice.initiatingMessage->value.present)
1006          {
1007             case InitiatingMessage__value_PR_F1SetupRequest:
1008             {
1009                DU_LOG("\nF1AP : F1 setup request received");
1010                BuildAndSendF1SetupRsp();
1011                break;
1012             }
1013
1014             case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
1015             {
1016                DU_LOG("\nF1AP : GNB-DU config update received");
1017                BuildAndSendDUUpdateAck();
1018                break;
1019             }
1020
1021             default:
1022             {
1023                DU_LOG("\nF1AP : Invalid type of intiating message [%d]",f1apMsg->choice.initiatingMessage->value.present);
1024                return;
1025             }
1026          }/* End of switch(initiatingMessage) */
1027          break;
1028       }
1029
1030    }/* End of switch(f1apMsg->present) */
1031
1032 } /* End of F1APMsgHdlr */
1033
1034 /**********************************************************************
1035   End of file
1036  **********************************************************************/