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