src/cu_stub/cu_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "cu_stub_sctp.h"
  25 #include "cu_f1ap_msg_hdl.h"
  26
  27 /*******************************************************************
  28 *
  29 * @brief Sends F1 msg over SCTP
  30 *
  31 * @details
  32 *
  33 *    Function : SendF1APMsg
  34 *
  35 *    Functionality: Sends F1 msg over SCTP
  36 *
  37 * @params[in] Region region
  38 *             Pool pool
  39 * @return ROK     - success
  40 *         RFAILED - failure
  41 *
  42 * ****************************************************************/
  43 S16 SendF1APMsg(Region region, Pool pool)
  44 {
  45    Buffer *mBuf = NULLP;
  46
  47    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
  48    {
  49       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
  50       {
  51          ODU_PRINT_MSG(mBuf, 0,0);
  52
  53          if(sctpSend(mBuf) != ROK)
  54          {
  55             DU_LOG("\nF1AP : SCTP Send failed");
  56             ODU_PUT_MSG_BUF(mBuf);
  57             return RFAILED;
  58          }
  59       }
  60       else
  61       {
  62          DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
  63          ODU_PUT_MSG_BUF(mBuf);
  64          return RFAILED;
  65       }
  66       ODU_PUT_MSG_BUF(mBuf);
  67    }
  68    else
  69    {
  70       DU_LOG("\nF1AP : Failed to allocate memory");
  71       return RFAILED;
  72    }
  73
  74    return ROK;
  75 } /* SendF1APMsg */
  76
  77 /*******************************************************************
  78 *
  79 * @brief Builds NRCell ID
  80 *
  81 * @details
  82 *
  83 *    Function : BuildNrCellId
  84 *
  85 *    Functionality: Building the NR Cell ID
  86 *
  87 * @params[in] BIT_STRING_t *nrcell
  88 * @return ROK     - success
  89 *         RFAILED - failure
  90 *
  91 * ****************************************************************/
  92
  93 S16 BuildNrCellId(BIT_STRING_t *nrcell)
  94 {
  95    U8 tmp;
  96    for (tmp = 0 ; tmp < nrcell->size-1; tmp++)
  97    {
  98       nrcell->buf[tmp] = 0;
  99    }
 100    nrcell->buf[4]   = 16;
 101    nrcell->bits_unused = 4;
 102    nrcell->size = 5 * sizeof(uint8_t);
 103    return ROK;
 104 }
 105
 106 /********************************************************************
 107  *
 108  * @brief Builds and sends the F1SetupResponse
 109  *
 110  * @details
 111  *
 112  *    Function : BuildAndSendF1SetupRsp
 113  *
 114  *    Functionality: Constructs the F1SetupResponse message and sends
 115  *                   it back to the DU through SCTP.
 116  *
 117  * @params[in] void **buf,Buffer to which encoded pattern is written into
 118  * @params[in] int *size,size of buffer
 119  *
 120  * @return ROK     - success
 121  *         RFAILED - failure
 122  *
 123  * ****************************************************************/
 124 S16 BuildAndSendF1SetupRsp()
 125 {
 126    U8    idx,idy;
 127    U8    elementCnt,cellCnt;
 128    F1AP_PDU_t         *f1apMsg = NULL;
 129    F1SetupResponse_t  *f1SetupRsp;
 130    GNB_CU_Name_t      *cuName;
 131    Cells_to_be_Activated_List_t *cellToActivate;
 132         RRC_Version_t      *rrcVer;
 133         asn_enc_rval_t     encRetVal;
 134         DU_LOG("\nF1AP : Building F1 Setup Response\n");
 135
 136    /* Allocate the memory for F1SetupRequest_t */
 137    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 138    if(f1apMsg == NULLP)
 139    {
 140       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 141       return RFAILED;
 142    }
 143    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 144
 145    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 146    if(f1apMsg->choice.successfulOutcome == NULLP)
 147    {
 148       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 149       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 150       return RFAILED;
 151    }
 152
 153    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 154    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 155    f1apMsg->choice.successfulOutcome->value.present = \
 156          SuccessfulOutcome__value_PR_F1SetupResponse;
 157    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 158
 159    elementCnt = 4;
 160    f1SetupRsp->protocolIEs.list.count = elementCnt;
 161    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 162
 163    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 164          elementCnt * sizeof(F1SetupResponseIEs_t *));
 165    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 166    {
 167       DU_LOG("\nF1AP : Memory allocation for F1ResponseIEs failed");
 168       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 169       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 170       return RFAILED;
 171    }
 172
 173    for(idx=0; idx<elementCnt; idx++)
 174    {
 175       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 176             sizeof(F1SetupResponseIEs_t));
 177       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 178       {
 179          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 180                elementCnt * sizeof(F1SetupResponseIEs_t *));
 181          CU_FREE(f1apMsg->choice.successfulOutcome, \
 182                sizeof(SuccessfulOutcome_t));
 183          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 184          return RFAILED;
 185       }
 186    }
 187
 188    /*TransactionID*/
 189    idx = 0;
 190    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 191    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 192    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 193                                      F1SetupResponseIEs__value_PR_TransactionID;
 194    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 195                                                                        TRANS_ID;
 196
 197    /*CU Name*/
 198    idx++;
 199    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 200    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 201    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 202                                        F1SetupResponseIEs__value_PR_GNB_CU_Name;
 203    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 204    cuName->size = sizeof(cuCfgParams.cuName);
 205
 206    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 207    if(cuName->buf == NULLP)
 208       {
 209          for(idy=0; idy<elementCnt; idy++)
 210          {
 211             CU_FREE(f1SetupRsp->protocolIEs.list.array[idy],\
 212                   sizeof(F1SetupResponseIEs_t));
 213          }
 214          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 215                elementCnt * sizeof(F1SetupResponseIEs_t *));
 216          CU_FREE(f1apMsg->choice.successfulOutcome,\
 217                sizeof(SuccessfulOutcome_t));
 218          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 219          return RFAILED;
 220       }
 221    strcpy((char*)cuName->buf, (char*)cuCfgParams.cuName);
 222
 223    /*Cells to be activated list*/
 224    idx++;
 225    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 226                               ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 227    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 228    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 229                      F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 230    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 231                     Cells_to_be_Activated_List;
 232    cellCnt=1;
 233    cellToActivate->list.count = cellCnt;
 234    cellToActivate->list.size = \
 235                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 236    CU_ALLOC(cellToActivate->list.array,\
 237          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 238    if(cellToActivate->list.array == NULLP)
 239    {
 240       CU_FREE(cuName->buf, sizeof(cuName->size));
 241       for(idy=0; idy<elementCnt; idy++)
 242       {
 243          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy],\
 244                sizeof(F1SetupResponseIEs_t));
 245       }
 246       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 247             elementCnt * sizeof(F1SetupResponseIEs_t *));
 248       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 249       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 250       return RFAILED;
 251    }
 252    for(idy=0; idy<cellCnt; idy++)
 253    {
 254       CU_ALLOC(cellToActivate->list.array[idy],\
 255             sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 256       if(cellToActivate->list.array[idy] == NULLP)
 257       {
 258          CU_FREE(cellToActivate->list.array,\
 259                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 260          CU_FREE(cuName->buf, sizeof(cuName->size));
 261          for(idy=0; idy<elementCnt; idy++)
 262          {
 263             CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 264                   sizeof(F1SetupResponseIEs_t));
 265          }
 266          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 267                elementCnt * sizeof(F1SetupResponseIEs_t *));
 268          CU_FREE(f1apMsg->choice.successfulOutcome, \
 269                sizeof(SuccessfulOutcome_t));
 270          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 271          return RFAILED;
 272       }
 273    }
 274    cellToActivate->list.array[0]->id = \
 275                               ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 276    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 277    cellToActivate->list.array[0]->value.present = \
 278        Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 279    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 280       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 281    CU_ALLOC(cellToActivate->list.array[0]->\
 282          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 283          3*sizeof(uint8_t));
 284    if(cellToActivate->list.array[0]->value.choice.\
 285          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 286    {
 287
 288       for(idy=0; idy<cellCnt; idy++)
 289       {
 290          CU_FREE(cellToActivate->list.array[idy],\
 291                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 292       }
 293
 294       CU_FREE(cellToActivate->list.array,\
 295             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 296       CU_FREE(cuName->buf, sizeof(cuName->size));
 297       for(idy=0; idy<elementCnt; idy++)
 298       {
 299          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 300                sizeof(F1SetupResponseIEs_t));
 301       }
 302       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 303             elementCnt * sizeof(F1SetupResponseIEs_t *));
 304       CU_FREE(f1apMsg->choice.successfulOutcome, \
 305             sizeof(SuccessfulOutcome_t));
 306       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 307       return RFAILED;
 308    }
 309     buildPlmnId(cuCfgParams.plmn , &cellToActivate->list.array[0]->value.choice.\
 310          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity);
 311    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 312       nRCGI.nRCellIdentity.size = 5;
 313    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 314          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 315          5*sizeof(uint8_t));
 316    if(cellToActivate->list.array[0]->value.choice.\
 317        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 318    {
 319       CU_FREE(cellToActivate->list.array[0]->\
 320           value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 321           3*sizeof(uint8_t));
 322       for(idy=0; idy<cellCnt; idy++)
 323       {
 324          CU_FREE(cellToActivate->list.array[idy],\
 325                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 326       }
 327
 328       CU_FREE(cellToActivate->list.array,\
 329             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 330       CU_FREE(cuName->buf, sizeof(cuName->size));
 331       for(idy=0; idy<elementCnt; idy++)
 332       {
 333          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 334                sizeof(F1SetupResponseIEs_t));
 335       }
 336       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 337             elementCnt * sizeof(F1SetupResponseIEs_t *));
 338       CU_FREE(f1apMsg->choice.successfulOutcome, \
 339             sizeof(SuccessfulOutcome_t));
 340       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 341       return RFAILED;
 342    }
 343    BuildNrCellId(&(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity));
 344    /* RRC Version */
 345    idx++;
 346    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 347                                         ProtocolIE_ID_id_GNB_CU_RRC_Version;
 348    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 349    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 350                                     F1SetupResponseIEs__value_PR_RRC_Version;
 351    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 352    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 353
 354    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 355    if(rrcVer->latest_RRC_Version.buf == NULLP)
 356    {
 357       CU_FREE(cuName->buf, sizeof(cuName->size));
 358       for(idy=0; idy<elementCnt; idx++)
 359       {
 360          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 361                sizeof(F1SetupResponseIEs_t));
 362       }
 363       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 364             elementCnt * sizeof(F1SetupResponseIEs_t *));
 365       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 366       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 367       return RFAILED;
 368    }
 369
 370   /* Need to check RRC Version */
 371    rrcVer->latest_RRC_Version.buf[0] = cuCfgParams.rrcVersion.rrcVer;
 372    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 373    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 374    if(rrcVer->iE_Extensions == NULLP)
 375    {
 376       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 377       CU_FREE(cuName->buf, sizeof(cuName->size));
 378       for(idy=0; idy<elementCnt; idy++)
 379       {
 380          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 381                sizeof(F1SetupResponseIEs_t));
 382       }
 383       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 384             elementCnt * sizeof(F1SetupResponseIEs_t *));
 385       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 386       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 387       return RFAILED;
 388    }
 389    rrcVer->iE_Extensions->list.count = 1;
 390    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 391    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 392          sizeof(struct RRC_Version_ExtIEs *));
 393    if(rrcVer->iE_Extensions->list.array == NULLP)
 394    {
 395       CU_FREE(rrcVer->iE_Extensions,\
 396             sizeof(ProtocolExtensionContainer_4624P81_t));
 397       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 398       CU_FREE(cuName->buf, sizeof(cuName->size));
 399       for(idy=0; idy<elementCnt; idy++)
 400       {
 401          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 402                sizeof(F1SetupResponseIEs_t));
 403       }
 404       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 405             elementCnt * sizeof(F1SetupResponseIEs_t *));
 406       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 407       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 408       return RFAILED;
 409    }
 410    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 411          sizeof(struct RRC_Version_ExtIEs));
 412    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 413    {
 414       CU_FREE(rrcVer->iE_Extensions->list.array,\
 415             sizeof(struct RRC_Version_ExtIEs *));
 416       CU_FREE(rrcVer->iE_Extensions,\
 417             sizeof(ProtocolExtensionContainer_4624P81_t));
 418       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 419       CU_FREE(cuName->buf, sizeof(cuName->size));
 420       for(idy=0; idy<elementCnt; idy++)
 421       {
 422          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 423                sizeof(F1SetupResponseIEs_t));
 424       }
 425       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 426             elementCnt * sizeof(F1SetupResponseIEs_t *));
 427       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 428       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 429       return RFAILED;
 430    }
 431    rrcVer->iE_Extensions->list.array[0]->id = \
 432                                 ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 433    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 434    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 435              RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 436    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 437       Latest_RRC_Version_Enhanced.size = 3*sizeof(U8);
 438    CU_ALLOC(rrcVer->iE_Extensions->list.\
 439          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 440          3*sizeof(U8));
 441    if(rrcVer->iE_Extensions->list.\
 442       array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 443    {
 444       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 445              sizeof(struct RRC_Version_ExtIEs));
 446       CU_FREE(rrcVer->iE_Extensions->list.array,\
 447             sizeof(struct RRC_Version_ExtIEs *));
 448       CU_FREE(rrcVer->iE_Extensions,\
 449             sizeof(ProtocolExtensionContainer_4624P81_t));
 450       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 451       CU_FREE(cuName->buf, sizeof(cuName->size));
 452       for(idy=0; idy<elementCnt; idy++)
 453       {
 454          CU_FREE(f1SetupRsp->protocolIEs.list.array[idy], \
 455                sizeof(F1SetupResponseIEs_t));
 456       }
 457       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 458             elementCnt * sizeof(F1SetupResponseIEs_t *));
 459       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 460       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 461       return RFAILED;
 462    }
 463    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 464       Latest_RRC_Version_Enhanced.buf[0] = 0;
 465    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 466       Latest_RRC_Version_Enhanced.buf[1] = 5;
 467    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 468       Latest_RRC_Version_Enhanced.buf[2] = 15;
 469
 470    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 471
 472    /* Encode the F1SetupRequest type as UPER */
 473    cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
 474    encBufSize = 0;
 475    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 476
 477    /* Clean up */
 478    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 479    CU_FREE(cuName->buf, sizeof(cuName->size));
 480    for(idx=0; idx<elementCnt; idx++)
 481    {
 482       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 483    }
 484    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 485    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 486    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 487
 488    /* Check encode results */
 489    if(encRetVal.encoded == ENCODE_FAIL)
 490    {
 491            DU_LOG("\nF1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 492                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 493            return RFAILED;
 494    }
 495    else
 496    {
 497            DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupResponse\n");
 498            for(int i=0; i< encBufSize; i++)
 499            {
 500                    printf("%x",encBuf[i]);
 501            }
 502    }
 503
 504    /* Sending msg */
 505    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 506    {
 507            DU_LOG("\nF1AP : Sending F1 Setup Response failed");
 508            return RFAILED;
 509    }
 510
 511    return ROK;
 512 }/* End of BuildAndSendF1SetupRsp */
 513
 514 /*******************************************************************
 515  *
 516  * @brief Builds and sends the DUUpdateAcknowledge
 517  *
 518  * @details
 519  *
 520  *    Function : BuildAndSendDUUpdateAck
 521  *
 522  *    Functionality: Constructs the DU Update Acknowledge message and sends
 523  *                   it to the DU through SCTP.
 524  *
 525  * @params[in] void **buf,Buffer to which encoded pattern is written into
 526  * @params[in] int *size,size of buffer
 527  *
 528  * @return ROK     - success
 529  *         RFAILED - failure
 530  *
 531  * ****************************************************************/
 532
 533 S16 BuildAndSendDUUpdateAck()
 534 {
 535    U8   idx;
 536    U8   elementCnt;
 537    F1AP_PDU_t *f1apMsg = NULL;
 538    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 539    asn_enc_rval_t enRetVal; /* Encoder return value */
 540
 541    DU_LOG("\nF1AP : Building GNB-DU Config Update Ack\n");
 542
 543    /* Allocate the memory for F1SetupRequest_t */
 544    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 545    if(f1apMsg == NULLP)
 546    {
 547       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 548       return RFAILED;
 549    }
 550
 551    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 552
 553    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 554    if(f1apMsg->choice.successfulOutcome == NULLP)
 555    {
 556       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 557       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 558       return RFAILED;
 559    }
 560
 561    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 562    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 563    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 564    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 565
 566    elementCnt = 1;
 567    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 568    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 569
 570    /* Initialize the F1Setup members */
 571    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 572    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 573    {
 574       DU_LOG("\nF1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 575       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 576       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 577       return RFAILED;
 578    }
 579
 580    for(idx=0; idx<elementCnt; idx++)
 581    {
 582       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 583       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 584       {
 585          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 586          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 587          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 588          return RFAILED;
 589       }
 590    }
 591
 592    /*TransactionID*/
 593    idx = 0;
 594    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 595    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 596    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present = GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 597    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 598
 599    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 600
 601    /* Encode the F1SetupRequest type as UPER */
 602    cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
 603    encBufSize = 0;
 604    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 605
 606    /* Clean up */
 607    for(idx=0; idx<elementCnt; idx++)
 608    {
 609       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 610    }
 611    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 612    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 613    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 614
 615    /* Checking encode results */
 616    if(enRetVal.encoded == ENCODE_FAIL)
 617    {
 618       DU_LOG("\nF1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 619       return RFAILED;
 620    }
 621    else
 622    {
 623     DU_LOG("\nF1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 624       for(int i=0; i< encBufSize; i++)
 625       {
 626          printf("%x",encBuf[i]);
 627       }
 628    }
 629
 630    /* Sending msg */
 631    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 632    {
 633       DU_LOG("\nF1AP : Sending GNB-DU Config Update Ack failed");
 634       return RFAILED;
 635    }
 636
 637    return ROK;
 638
 639 }/* End of BuildAndSendDUUpdateAck*/
 640
 641 /*******************************************************************
 642  *
 643  * @brief Fills Radio Bearer Config
 644  *
 645  * @details
 646  *
 647  *    Function : fillRadioBearerConfig
 648  *
 649  *    Functionality: Fills Radio Bearer Config
 650  *
 651  * @params[in] SRB_ToAddModList *
 652  *
 653  * @return ROK     - success
 654  *         RFAILED - failure
 655  *
 656  * ****************************************************************/
 657 uint8_t fillRadioBearerConfig(SRB_ToAddModList_t *bearerCfg)
 658 {
 659    uint8_t elementCnt;
 660    uint8_t idx;
 661    uint8_t ied;
 662    if(bearerCfg != NULLP)
 663    {
 664       elementCnt = 1;
 665       bearerCfg->list.count = elementCnt;
 666       bearerCfg->list.size =\
 667            elementCnt * sizeof(SRB_ToAddMod_t *);
 668       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 669       if(bearerCfg->list.array != NULLP)
 670       {
 671          for(idx = 0; idx < elementCnt; idx++)
 672          {
 673             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 674             if(bearerCfg->list.array[idx] == NULLP)
 675             {
 676                for(ied = 0; ied < idx; ied++)
 677                {
 678                   CU_FREE(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 679                }
 680                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 681                return RFAILED;
 682             }
 683          }
 684       }
 685                 else
 686                 {
 687                    return RFAILED;
 688                 }
 689       idx = 0;
 690       bearerCfg->list.array[idx]->srb_Identity = SRB1;
 691    }
 692    return ROK;
 693 }
 694
 695 /*******************************************************************
 696  *
 697  * @brief Fills Master CellGroup Info
 698  *
 699  * @details
 700  *
 701  *    Function : fillMasterCellGroup
 702  *
 703  *    Functionality: Fills Master Cell Group IE
 704  *
 705  * @params[in] RRCSetup_IEs_t *
 706  *
 707  * @return ROK     - success
 708  *         RFAILED - failure
 709  *
 710  * ****************************************************************/
 711
 712 uint8_t fillMasterCellGroup(OCTET_STRING_t *masterCellGroup)
 713 {
 714    uint8_t ret = ROK;
 715    masterCellGroup->buf = NULLP;
 716         if(f1apMsgDb.duToCuContainer.buf)
 717         {
 718       masterCellGroup->size = f1apMsgDb.duToCuContainer.size;
 719       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 720       if(masterCellGroup->buf != NULLP)
 721       {
 722          memcpy(masterCellGroup->buf, f1apMsgDb.duToCuContainer.buf,\
 723                           masterCellGroup->size);
 724       }
 725            else
 726            {
 727               ret = RFAILED;
 728            }
 729         }
 730         else
 731         {
 732            ret =  RFAILED;
 733    }
 734    return ret;
 735 }
 736
 737 /*******************************************************************
 738  *
 739  * @brief Fills RRC setup IE
 740  *
 741  * @details
 742  *
 743  *    Function : fillRRCSetupIE
 744  *
 745  *    Functionality: Fills RRC Setup IE
 746  *
 747  * @params[in] RRCSetup_IEs_t *
 748  *
 749  * @return ROK     - success
 750  *         RFAILED - failure
 751  *
 752  * ****************************************************************/
 753
 754 uint8_t fillRRCSetupIE(RRCSetup_IEs_t *rrcSetupIE)
 755 {
 756    uint8_t ret = ROK;
 757    if(rrcSetupIE)
 758    {
 759       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
 760                 if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
 761                 {
 762          ret = fillRadioBearerConfig(rrcSetupIE->radioBearerConfig.srb_ToAddModList);
 763            }
 764       if(!ret)
 765       {
 766          ret = fillMasterCellGroup(&rrcSetupIE->masterCellGroup);
 767       }
 768                 else
 769                 {
 770                    CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
 771                         ret = RFAILED;
 772            }
 773    }
 774    return ret;
 775 }
 776 /*******************************************************************
 777  *
 778  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
 779  *
 780  * @details
 781  *
 782  *    Function : BuildDLRRCContainer
 783  *
 784  *    Functionality: Builds RRC Container IE required for
 785  *                   DLRRCMessageTransfer
 786  *
 787  * @params[in]
 788  *
 789  * @return ROK     - success
 790  *         RFAILED - failure
 791  *
 792  * ****************************************************************/
 793
 794 uint8_t BuildDLRRCContainer(RRCContainer_t *rrcContainer)
 795 {
 796    uint8_t ret = ROK;
 797         uint16_t idx2;
 798    DL_CCCH_Message_t dl_CCCH_Msg;
 799    asn_enc_rval_t        encRetVal;
 800
 801    if(rrcContainer != NULLP)
 802    {
 803       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
 804
 805       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
 806       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
 807       {
 808          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
 809          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
 810          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
 811          {
 812             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
 813             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
 814               present = RRCSetup__criticalExtensions_PR_rrcSetup;
 815                                 /* Fill RRC Setup IE */
 816             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 817               criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
 818             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 819                 criticalExtensions.choice.rrcSetup != NULLP)
 820             {
 821                ret = fillRRCSetupIE(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
 822                criticalExtensions.choice.rrcSetup);
 823
 824                if(!ret)
 825                                         {
 826                   /* encode DL-CCCH message into RRC Container */
 827                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
 828                   cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
 829                   encBufSize = 0;
 830                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
 831                   /* Encode results */
 832                   if(encRetVal.encoded == ENCODE_FAIL)
 833                   {
 834                      DU_LOG( "\n F1AP : Could not encode RRCContainer (at %s)\n",\
 835                           encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 836                           return RFAILED;
 837                   }
 838                   else
 839                   {
 840                      DU_LOG("\n F1AP : Created APER encoded buffer for RRCContainer\n");
 841                         for(int i = 0; i< encBufSize; i++)
 842                         {
 843                            printf("%x",encBuf[i]);
 844                         }
 845                      rrcContainer->size = encBufSize;
 846                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
 847                      if(rrcContainer->buf != NULLP)
 848                      {
 849                         memset(rrcContainer->buf, 0, encBufSize);
 850                              for(idx2 = 0; idx2 < encBufSize; idx2++)
 851                              {
 852                                 rrcContainer->buf[idx2] =       encBuf[idx2];
 853                         }
 854                      }
 855                                                 }
 856                                         }
 857                                         else
 858                                         {
 859                                            ret = RFAILED;
 860                                         }
 861             }
 862                                 else
 863                                 {
 864                     DU_LOG("\nF1AP: Memory Alloc failed for RRC Setup Msg");
 865                ret = RFAILED;
 866                                 }
 867          }
 868                         else
 869                         {
 870                   DU_LOG("\nF1AP: Memory Alloc failed for RRC Msg");
 871              ret = RFAILED;
 872                         }
 873       }
 874                 else
 875                 {
 876               DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice");
 877          ret = RFAILED;
 878                 }
 879    }
 880         else
 881         {
 882            DU_LOG("\nF1AP: Memory Alloc failed for DlCcch Msg");
 883       ret = RFAILED;
 884         }
 885    return ret;
 886 }
 887
 888 /*******************************************************************
 889  *
 890  * @brief Builds and sends the DLRRCMessageTransfer
 891  *
 892  * @details
 893  *
 894  *    Function : BuildAndSendDLRRCMessageTransfer
 895  *
 896  *    Functionality: Constructs the DL RRC Message Transfer and sends
 897  *                   it to the CU through SCTP.
 898  *
 899  * @params[in]
 900  *
 901  * @return ROK     - success
 902  *         RFAILED - failure
 903  *
 904  * ****************************************************************/
 905 S16 BuildAndSendDLRRCMessageTransfer()
 906 {
 907    uint8_t   elementCnt = 0;
 908    uint8_t  ieId;
 909    uint8_t  idx;
 910    F1AP_PDU_t  *f1apMsg = NULLP;
 911    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
 912    asn_enc_rval_t   encRetVal;        /* Encoder return value */
 913
 914    DU_LOG("\n F1AP : Building DL RRC Message Transfer Message\n");
 915
 916    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 917    if(f1apMsg == NULLP)
 918    {
 919       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
 920       return RFAILED;
 921    }
 922
 923    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 924    CU_ALLOC(f1apMsg->choice.initiatingMessage,
 925       sizeof(InitiatingMessage_t));
 926    if(f1apMsg->choice.initiatingMessage == NULLP)
 927    {
 928       DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
 929       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 930       return RFAILED;
 931    }
 932
 933    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
 934    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
 935    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
 936    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
 937
 938    elementCnt = 4;
 939    dlRRCMsg->protocolIEs.list.count = elementCnt;
 940    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
 941
 942    /* Initialize the F1Setup members */
 943    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
 944    if(dlRRCMsg->protocolIEs.list.array == NULLP)
 945    {
 946       DU_LOG(" F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
 947       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 948       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 949       return RFAILED;
 950    }
 951
 952    for(idx=0; idx<elementCnt; idx++)
 953    {
 954       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
 955       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
 956       {
 957          for(ieId=0; ieId<idx; ieId++)
 958          {
 959              CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId],\
 960                        sizeof(DLRRCMessageTransferIEs_t));
 961          }
 962          CU_FREE(dlRRCMsg->protocolIEs.list.array,\
 963            dlRRCMsg->protocolIEs.list.size);
 964          CU_FREE(f1apMsg->choice.initiatingMessage,\
 965            sizeof(InitiatingMessage_t));
 966          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
 967          return RFAILED;
 968       }
 969    }
 970
 971    /* GNB CU UE F1AP ID */
 972    idx = 0;
 973    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
 974    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
 975    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
 976                          DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
 977    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
 978
 979    /* GNB DU UE F1AP ID */
 980    idx++;
 981    dlRRCMsg->protocolIEs.list.array[idx]->id  = \
 982                                    ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
 983    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
 984    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
 985                          DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
 986    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
 987
 988    /* SRBID */
 989    idx++;
 990    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
 991    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
 992    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
 993                                  DLRRCMessageTransferIEs__value_PR_SRBID;
 994    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = SRB1;
 995
 996    /* RRCContainer */
 997    idx++;
 998    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
 999    dlRRCMsg->protocolIEs.list.array[idx]->criticality   = Criticality_reject;
1000    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1001                                      DLRRCMessageTransferIEs__value_PR_RRCContainer;
1002         BuildDLRRCContainer(&dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1003
1004    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1005
1006    /* Encode the F1SetupRequest type as APER */
1007    cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
1008    encBufSize = 0;
1009    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1010        encBuf);
1011    /* Encode results */
1012    if(encRetVal.encoded == ENCODE_FAIL)
1013    {
1014      DU_LOG( "\n F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1015          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1016      return RFAILED;
1017    }
1018    else
1019    {
1020      DU_LOG("\n F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1021      for(int i=0; i< encBufSize; i++)
1022      {
1023        printf("%x",encBuf[i]);
1024      }
1025    }
1026
1027    /* Sending  msg  */
1028    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=  ROK)
1029    {
1030      DU_LOG("\n F1AP : Sending  DL RRC Message Transfer Failed");
1031      return RFAILED;
1032    }
1033
1034    return ROK;
1035 }/* End of BuildAndSendDLRRCMessageTransfer */
1036
1037 /*******************************************************************
1038  *
1039  * @brief Builds and sends the UE Setup Response
1040  *
1041  * @details
1042  *
1043  *    Function : BuildAndSendUESetRsp
1044  *
1045  *    Functionality: Constructs the UE Setup Response and sends
1046  *                   it to the DU through SCTP.
1047  *
1048  * @params[in]
1049  *
1050  * @return ROK     - success
1051  *         RFAILED - failure
1052  *
1053  * ****************************************************************/
1054 S16 BuildAndSendUESetRsp()
1055 {
1056         S16  ret;
1057         U8   elementCnt;
1058         U8   cellCnt;
1059         U8   ieId;
1060         U8   idx;
1061         U8   drbCnt;
1062         U8   drbId;
1063         F1AP_PDU_t                                                      *f1apMsg = NULL;
1064    UEContextSetupResponse_t                     *ueSetRsp;
1065         asn_enc_rval_t                                                  encRetVal;        /* Encoder return value */
1066
1067         DU_LOG("\n F1AP : Building UE Context Setup Response\n");
1068
1069         CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1070         if(f1apMsg == NULLP)
1071         {
1072                 DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1073                 return RFAILED;
1074         }
1075
1076         f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
1077         CU_ALLOC(f1apMsg->choice.successfulOutcome,
1078                         sizeof(SuccessfulOutcome_t));
1079         if(f1apMsg->choice.successfulOutcome == NULLP)
1080         {
1081                 DU_LOG(" F1AP : Memory allocation for   F1AP-PDU failed");
1082                 CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1083                 return RFAILED;
1084         }
1085
1086         f1apMsg->choice.successfulOutcome->procedureCode = \
1087                                                                                                         ProcedureCode_id_UEContextSetup;
1088         f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
1089         f1apMsg->choice.successfulOutcome->value.present = \
1090                                    SuccessfulOutcome__value_PR_UEContextSetupResponse;
1091         ueSetRsp =
1092                 &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
1093         elementCnt = 2;
1094         ueSetRsp->protocolIEs.list.count = elementCnt;
1095         ueSetRsp->protocolIEs.list.size = \
1096                                                                         elementCnt * sizeof(UEContextSetupResponse_t *);
1097
1098         /* Initialize the UESetup members */
1099         CU_ALLOC(ueSetRsp->protocolIEs.list.array, \
1100                                 ueSetRsp->protocolIEs.list.size);
1101         if(ueSetRsp->protocolIEs.list.array == NULLP)
1102         {
1103                 DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
1104                 CU_FREE(f1apMsg->choice.successfulOutcome,
1105                                 sizeof(SuccessfulOutcome_t));
1106                 CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
1107                 return RFAILED;
1108         }
1109
1110         for(idx=0; idx<elementCnt; idx++)
1111         {
1112                 CU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
1113                                                                                 sizeof(UEContextSetupResponseIEs_t));
1114                 if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
1115                 {
1116                         for(ieId=0; ieId<idx; ieId++)
1117                         {
1118                                 CU_FREE(ueSetRsp->protocolIEs.list.array[ieId],\
1119                                                 sizeof(UEContextSetupResponseIEs_t));
1120                         }
1121                         CU_FREE(ueSetRsp->protocolIEs.list.array,\
1122                                                  ueSetRsp->protocolIEs.list.size);
1123                         CU_FREE(f1apMsg->choice.successfulOutcome,\
1124                                                                                                 sizeof(SuccessfulOutcome_t));
1125                         CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1126                         return RFAILED;
1127                 }
1128         }
1129
1130         idx = 0;
1131
1132         /*GNB CU UE F1AP ID*/
1133         ueSetRsp->protocolIEs.list.array[idx]->id       = \
1134                                                                                  ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1135         ueSetRsp->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
1136         ueSetRsp->protocolIEs.list.array[idx]->value.present = \
1137                                                 UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
1138         ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
1139
1140         /*GNB DU UE F1AP ID*/
1141         idx++;
1142         ueSetRsp->protocolIEs.list.array[idx]->id       = \
1143                                                                                  ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1144         ueSetRsp->protocolIEs.list.array[idx]->criticality      =       Criticality_reject;
1145         ueSetRsp->protocolIEs.list.array[idx]->value.present = \
1146                                                 UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
1147         ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
1148
1149
1150         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1151
1152         /* Encode the F1SetupRequest type as APER */
1153         cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
1154         encBufSize = 0;
1155         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1156                         encBuf);
1157         /* Encode results */
1158         if(encRetVal.encoded == ENCODE_FAIL)
1159         {
1160                 DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
1161                                 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1162                 return RFAILED;
1163         }
1164         else
1165         {
1166                 DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
1167                 for(int i=0; i< encBufSize; i++)
1168                 {
1169                         printf("%x",encBuf[i]);
1170                 }
1171         }
1172
1173         /* Sending  msg  */
1174         if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=      ROK)
1175         {
1176                 DU_LOG("\n F1AP : Sending       UE Context Setup Request Failed");
1177                 return RFAILED;
1178         }
1179
1180         return ROK;
1181 }/* End of BuildAndSendUESetRsp */
1182
1183 uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
1184 {
1185    uint8_t idx;
1186    uint8_t ret =ROK;
1187    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1188    DU_LOG("\n filling the required values in DB in procInitULRRCMsg");
1189
1190    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1191
1192    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
1193    {
1194       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
1195       {
1196          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
1197          break;
1198          case ProtocolIE_ID_id_NRCGI:
1199          break;
1200          case ProtocolIE_ID_id_C_RNTI:
1201          break;
1202          case ProtocolIE_ID_id_RRCContainer:
1203          break;
1204          case ProtocolIE_ID_id_DUtoCURRCContainer:
1205                            {
1206                                    if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
1207                                            .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
1208                                                 .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
1209                {
1210                   DU_LOG("\n Received Du to Cu RRC Container ");
1211                   f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
1212                    .list.array[idx]->value.choice.DUtoCURRCContainer.size;
1213                   CU_ALLOC(f1apMsgDb.duToCuContainer.buf, \
1214                                                  f1apMsgDb.duToCuContainer.size);
1215                   if(f1apMsgDb.duToCuContainer.buf != NULLP)
1216                   {
1217                      memcpy(f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
1218                       .list.array[idx]->value.choice.DUtoCURRCContainer.buf, f1apMsgDb\
1219                       .duToCuContainer.size);
1220                   }
1221                }
1222                                    else
1223                                    {
1224                   DU_LOG("\n Failed to receive Du to Cu RRC Container ");
1225                                         ret = RFAILED;
1226                               }
1227                break;
1228                            }
1229          default:
1230             DU_LOG("\n Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
1231             break;
1232       }
1233    }
1234         if(!ret)
1235            ret = BuildAndSendDLRRCMessageTransfer();
1236    return ret;
1237 }
1238
1239 /*******************************************************************
1240  *
1241  * @brief Builds Nrcgi
1242  *
1243  * @details
1244  *
1245  *    Function : BuildNrcgi
1246  *
1247  *    Functionality: Building the PLMN ID and NR Cell id
1248  *
1249  * @params[in] NRCGI_t *nrcgi
1250  * @return ROK     - success
1251  *         RFAILED - failure
1252  *
1253  * ****************************************************************/
1254 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
1255 {
1256    uint8_t ret;
1257    uint8_t unused = 4;
1258    uint8_t byteSize = 5;
1259    uint8_t val = 16;
1260    /* Allocate Buffer Memory */
1261    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
1262    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1263    if(nrcgi->pLMN_Identity.buf == NULLP)
1264    {
1265       return RFAILED;
1266    }
1267    ret = buildPlmnId(cuCfgParams.plmn , &nrcgi->pLMN_Identity);
1268
1269    if(ret != ROK)
1270    {
1271       return RFAILED;
1272    }
1273    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
1274    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1275    if(nrcgi->nRCellIdentity.buf == NULLP)
1276    {
1277       return RFAILED;
1278    }
1279    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
1280    if(ret != ROK)
1281    {
1282       return RFAILED;
1283    }
1284    return ROK;
1285 }
1286 /*******************************************************************
1287  *
1288  * @brief Builds Special cell list for UE Setup Request
1289  *
1290  * @details
1291  *
1292  *    Function : BuildSplCellList
1293  *
1294  *    Functionality: Constructs the Special Cell list for UESetReq
1295  *
1296  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1297  *
1298  * @return ROK     - success
1299  *         RFAILED - failure
1300  *
1301  * ****************************************************************/
1302 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1303 {
1304    uint8_t  cellCnt;
1305    uint8_t  idx;
1306    uint8_t  ret;
1307    cellCnt = 1;
1308    spCellLst->list.count = cellCnt;
1309    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
1310    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
1311    if(spCellLst->list.array == NULLP)
1312    {
1313       return RFAILED;
1314    }
1315    for(idx=0; idx<cellCnt; idx++)
1316    {
1317       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1318       if(spCellLst->list.array[idx] == NULLP)
1319       {
1320          return RFAILED;
1321       }
1322    }
1323    idx = 0;
1324    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
1325    spCellLst->list.array[idx]->criticality = Criticality_ignore;
1326    spCellLst->list.array[idx]->value.present =\
1327                                               SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
1328    /* Special Cell ID -NRCGI */
1329    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1330    if(ret != ROK)
1331    {
1332       return RFAILED;
1333    }
1334    /*Special Cell Index*/
1335    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
1336    return ROK;
1337 }/* End of BuildSplCellList*/
1338
1339 /*******************************************************************
1340  *
1341  * @brief Builds SRBS to be setup
1342  *
1343  * @details
1344  *
1345  *    Function : BuildSRBSetup
1346  *
1347  *    Functionality: Constructs the SRB's for UESetReq
1348  *
1349  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1350  *
1351  * @return ROK     - success
1352  *         RFAILED - failure
1353  *
1354  * ****************************************************************/
1355 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1356 {
1357    uint8_t idx;
1358    uint8_t srbCnt;
1359    srbCnt = 1;
1360    srbSet->list.count = srbCnt;
1361    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
1362    CU_ALLOC(srbSet->list.array,srbSet->list.size);
1363    if(srbSet->list.array == NULLP)
1364    {
1365       return RFAILED;
1366    }
1367    for(idx=0; idx<srbCnt; idx++)
1368    {
1369       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1370       if(srbSet->list.array[idx] == NULLP)
1371       {
1372          return RFAILED;
1373       }
1374    }
1375    idx = 0;
1376    srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
1377    srbSet->list.array[idx]->criticality = Criticality_ignore;
1378    srbSet->list.array[idx]->value.present = \
1379       SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
1380    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
1381    return ROK;
1382 }/* End of BuildSRBSetup*/
1383
1384 /*******************************************************************
1385  *
1386  * @brief Builds QOS Info for DRB Setum Item
1387  *
1388  * @details
1389  *
1390  *    Function : BuildQOSInfo
1391  *
1392  *    Functionality: Constructs the QOS Info for DRB Setup Item
1393  *
1394  * @params[in] QoSInformation_t *qosinfo
1395  *
1396  * @return ROK     - success
1397  *         RFAILED - failure
1398  *
1399  * ****************************************************************/
1400 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
1401 {
1402    /* NonDynamic5QIDescriptor */
1403    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
1404    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
1405    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
1406    {
1407       return RFAILED;
1408    }
1409    /*FiveQI*/
1410    drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
1411    /*AveragingWindow*/
1412    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
1413          sizeof(AveragingWindow_t));
1414    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
1415          NULLP)
1416    {
1417       return RFAILED;
1418    }
1419    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
1420    /*MaxDataBurstVolume*/
1421    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
1422          sizeof(MaxDataBurstVolume_t));
1423    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
1424          NULLP)
1425    {
1426       return RFAILED;
1427    }
1428    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
1429
1430    /*nRGRAN Allocation Retention Priority*/
1431    drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_highest;
1432    drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
1433    drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
1434
1435    /* TO DO: GBR_QoSFlowInformation */
1436    return ROK;
1437 }/*End of BuildQOSInfo*/
1438
1439 /*******************************************************************
1440  *
1441  * @brief Builds SNSSAI
1442  *
1443  * @details
1444  *
1445  *    Function : BuildSNSSAI
1446  *
1447  *    Functionality: Constructs the SNSSAI For DRB list
1448  *
1449  * @params[in] SNSSAI_t *snssai
1450  *
1451  * @return ROK     - success
1452  *         RFAILED - failure
1453  *
1454  * ****************************************************************/
1455 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
1456 {
1457    /*SNSSAI*/
1458    /*ssT*/
1459    snssai->sST.size = sizeof(uint8_t);
1460    CU_ALLOC(snssai->sST.buf,snssai->sST.size);
1461    if(snssai->sST.buf == NULLP)
1462    {
1463       return RFAILED;
1464    }
1465    snssai->sST.buf[0] = 3;
1466    /*sD*/
1467    CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
1468    if(snssai->sD == NULLP)
1469    {
1470       return RFAILED;
1471    }
1472    snssai->sD->size = 3*sizeof(uint8_t);
1473    CU_ALLOC(snssai->sD->buf,snssai->sD->size);
1474    if(snssai->sD->buf == NULLP)
1475    {
1476       return RFAILED;
1477    }
1478    snssai->sD->buf[0] = 3;
1479    snssai->sD->buf[1] = 6;
1480    snssai->sD->buf[2] = 9;
1481    return ROK;
1482 }/*End of BuildSNSSAI*/
1483
1484 /*******************************************************************
1485  *
1486  * @brief Builds the flow map.
1487  *
1488  * @details
1489  *
1490  *    Function : BuildFlowsMap
1491  *
1492  *    Functionality: Constructs the flowmap For DRB list
1493  *
1494  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
1495  *
1496  * @return ROK     - success
1497  *         RFAILED - failure
1498  *
1499  * ****************************************************************/
1500 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
1501 {
1502    uint8_t  ret;
1503    uint8_t  idx;
1504    uint8_t  flowCnt;
1505    flowCnt = 1;
1506    flowMap->list.count = flowCnt;
1507    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
1508    CU_ALLOC(flowMap->list.array,flowMap->list.size);
1509    if(flowMap->list.array == NULLP)
1510    {
1511       return RFAILED;
1512    }
1513    for(idx=0; idx<flowCnt; idx++)
1514    {
1515       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
1516       if(flowMap->list.array[idx] == NULLP)
1517       {
1518          return RFAILED;
1519       }
1520    }
1521    idx = 0;
1522    flowMap->list.array[idx]->qoSFlowIdentifier = 0;
1523    ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
1524    if(ret != ROK)
1525    {
1526       return RFAILED;
1527    }
1528    return ROK;
1529 }/*End of BuildFlowsMap*/
1530
1531 /*******************************************************************
1532  *
1533  * @brief Builds the Uplink Tunnel Info
1534  *
1535  * @details
1536  *
1537  *    Function : BuildULTnlInfo
1538  *
1539  *    Functionality: Constructs the UL TnlInfo For DRB list
1540  *
1541  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
1542  *
1543  * @return ROK     - success
1544  *         RFAILED - failure
1545  *
1546  * ****************************************************************/
1547 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
1548 {
1549    uint8_t idx;
1550    uint8_t ulCnt;
1551    ulCnt = 1;
1552    ulInfo->list.count = ulCnt;
1553    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
1554    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
1555    if(ulInfo->list.array == NULLP)
1556    {
1557       return RFAILED;
1558    }
1559    for(idx=0; idx<ulCnt; idx++)
1560    {
1561       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
1562       if(ulInfo->list.array[idx] == NULLP)
1563       {
1564          return RFAILED;
1565       }
1566    }
1567    idx = 0;
1568    ulInfo->list.array[idx]->uLUPTNLInformation.present = \
1569                                                          UPTransportLayerInformation_PR_gTPTunnel;
1570    /*GTP TUNNEL*/
1571    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
1572          sizeof(GTPTunnel_t));
1573    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
1574    {
1575       return RFAILED;
1576    }
1577    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1578       transportLayerAddress.size        = 4*sizeof(uint8_t);
1579    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1580          transportLayerAddress.buf,ulInfo->list.array[idx]->\
1581          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
1582    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1583          transportLayerAddress.buf == NULLP)
1584    {
1585       return RFAILED;
1586    }
1587    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1588       transportLayerAddress.buf[0] = 4;
1589    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1590       transportLayerAddress.buf[1] = 4;
1591    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1592       transportLayerAddress.buf[2] = 4;
1593    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1594       transportLayerAddress.buf[3] = 5;
1595    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1596       transportLayerAddress.bits_unused = 0;
1597    /*GTP TEID*/
1598    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
1599       = 4 * sizeof(uint8_t);
1600    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1601          gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
1602          gTPTunnel->gTP_TEID.size);
1603    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
1604          == NULLP)
1605    {
1606       return RFAILED;
1607    }
1608    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1609       gTP_TEID.buf[0] = 11;
1610    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1611       gTP_TEID.buf[1] = 0;
1612    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1613       gTP_TEID.buf[2] = 0;
1614    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
1615       gTP_TEID.buf[3] = 1;
1616
1617    return ROK;
1618 }/*End of BuildULTnlInfo*/
1619
1620 /*******************************************************************
1621  *
1622  * @brief Builds DRBS to be setup
1623  *
1624  * @details
1625  *
1626  *    Function : BuildDRBSetup
1627  *
1628  *    Functionality: Constructs the DRB's for UESetReq
1629  *
1630  * @params[in] DRBs_ToBeSetup_List_t *drbSet
1631  *
1632  * @return ROK     - success
1633  *         RFAILED - failure
1634  *
1635  * ****************************************************************/
1636 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
1637 {
1638    uint8_t BuildQOSInforet;
1639    uint8_t BuildSNSSAIret;
1640    uint8_t BuildFlowsMapret;
1641    uint8_t BuildULTnlInforet;
1642    uint8_t idx;
1643    uint8_t drbCnt;
1644    DRBs_ToBeSetup_Item_t *drbSetItem;
1645    drbCnt = 1;
1646    drbSet->list.count = drbCnt;
1647    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
1648    CU_ALLOC(drbSet->list.array,drbSet->list.size);
1649    if(drbSet->list.array == NULLP)
1650    {
1651       return RFAILED;
1652    }
1653    for(idx=0; idx<drbCnt; idx++)
1654    {
1655       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
1656       if(drbSet->list.array[idx] == NULLP)
1657       {
1658          return RFAILED;
1659       }
1660    }
1661    idx = 0;
1662    drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
1663    drbSet->list.array[idx]->criticality = Criticality_ignore;
1664    drbSet->list.array[idx]->value.present = \
1665                                             DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
1666    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
1667    /*dRBID*/
1668    drbSetItem->dRBID = 1;
1669    /*qoSInformation*/
1670    drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
1671    CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
1672    if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
1673    {
1674       return RFAILED;
1675    }
1676    drbSetItem->qoSInformation.choice.choice_extension->id = \
1677                                                             ProtocolIE_ID_id_DRB_Information;
1678    drbSetItem->qoSInformation.choice.choice_extension->criticality = \
1679                                                                      Criticality_ignore;
1680    drbSetItem->qoSInformation.choice.choice_extension->value.present = \
1681                                                                        QoSInformation_ExtIEs__value_PR_DRB_Information;
1682   BuildQOSInforet =  BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
1683          choice_extension->value.choice.DRB_Information.dRB_QoS);
1684    if(BuildQOSInforet != ROK)
1685    {
1686       return RFAILED;
1687    }
1688    /*SNSSAI*/
1689    BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
1690          choice_extension->value.choice.DRB_Information.sNSSAI);
1691    if(BuildSNSSAIret != ROK)
1692    {
1693       return RFAILED;
1694    }
1695    /*Flows mapped to DRB List*/
1696    BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
1697          choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
1698    if(BuildFlowsMapret != ROK)
1699    {
1700       return RFAILED;
1701    }
1702    /*ULUPTNLInformation To Be Setup List*/
1703    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
1704    if(BuildULTnlInforet != ROK)
1705    {
1706       return RFAILED;
1707    }
1708    /*RLCMode*/
1709    drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
1710
1711    /*UL Configuration*/
1712    CU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
1713    if(drbSetItem->uLConfiguration == NULLP)
1714    {
1715       return RFAILED;
1716    }
1717    drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
1718    return ROK;
1719 }/* End of BuildDRBSetup*/
1720
1721 /*******************************************************************
1722  *
1723  * @brief Deallocating memory of function BuildAndSendUESetReq
1724  *
1725  * @details
1726  *
1727  *    Function : FreeNrcgi
1728  *
1729  *    Functionality: Deallocating memory for function BuildNrcgi
1730  *
1731  * @params[in] NRCGI_t *nrcgi
1732  *
1733  * @return void
1734  *
1735  *******************************************************************/
1736 void FreeNrcgi(NRCGI_t *nrcgi)
1737 {
1738    if(nrcgi->pLMN_Identity.buf != NULLP)
1739    {
1740       if(nrcgi->nRCellIdentity.buf != NULLP)
1741       {
1742          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1743       }
1744       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1745    }
1746 }
1747 /*******************************************************************
1748  *
1749  * @brief  Deallocating memory of function BuildAndSendUESetReq
1750  *
1751  * @details
1752  *
1753  *    Function : FreeSplCellList
1754  *
1755  *    Functionality: Deallocating memory for function BuildSplCellList
1756  *
1757  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1758  *
1759  * @return void
1760  *
1761  *
1762  * *****************************************************************/
1763 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1764 {
1765    uint8_t  cellidx;
1766    if(spCellLst->list.array != NULLP)
1767    {
1768       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
1769       {
1770          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
1771          {
1772             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1773          }
1774          if(spCellLst->list.array[cellidx]!=NULLP)
1775          {
1776             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1777          }
1778       }
1779       CU_FREE(spCellLst->list.array,spCellLst->list.size);
1780    }
1781 }
1782 /*******************************************************************
1783  *
1784  * @brief Deallocating memory of function BuildAndSendUESetReq
1785  *
1786  * @details
1787  *
1788  *    Function : FreeSRBSetup
1789  *
1790  *    Functionality: Deallocating memory for function BuildSRBSetup
1791  *
1792  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1793  *
1794  * @return void
1795  *
1796  *
1797  * ******************************************************************/
1798 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1799 {
1800    uint8_t srbidx;
1801    if(srbSet->list.array != NULLP)
1802    {
1803       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
1804       {
1805          if(srbSet->list.array[srbidx]!=NULLP)
1806          {
1807             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1808          }
1809       }
1810       CU_FREE(srbSet->list.array,srbSet->list.size);
1811    }
1812 }
1813 /*******************************************************************
1814  *
1815  * @brief Deallocating memory of function BuildAndSendUESetReq
1816  *
1817  * @details
1818  *
1819  *    Function : FreeQOSInfo
1820  *
1821  *    Functionality:  Deallocating memory for function BuildQOSInfo
1822  *
1823  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
1824  *
1825  * @return void
1826  *
1827  * ****************************************************************/
1828 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
1829 {
1830    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
1831    {
1832       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
1833       {
1834          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
1835          {
1836             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
1837                   sizeof(MaxDataBurstVolume_t));
1838          }
1839          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
1840                sizeof(AveragingWindow_t));
1841       }
1842       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
1843             sizeof(NonDynamic5QIDescriptor_t));
1844    }
1845 }
1846 /*******************************************************************
1847  *
1848  * @brief Deallocating memory of function BuildAndSendUESetReq
1849  *
1850  * @details
1851  *
1852  *    Function : FreeULTnlInfo
1853  *
1854  *    Functionality:  Deallocating memory for function BuildULTnlInfo
1855  *
1856  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
1857  *
1858  * @return void
1859  *
1860
1861  * ****************************************************************/
1862 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
1863 {
1864    uint8_t ulidx=0;
1865    if(ulInfo->list.array != NULLP)
1866    {
1867       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
1868       {
1869          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
1870          {
1871             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
1872             {
1873                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
1874                      transportLayerAddress.buf != NULLP)
1875                {
1876                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
1877                         !=NULLP)
1878                   {
1879                      CU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
1880                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
1881                            gTPTunnel->gTP_TEID.size);
1882                   }
1883                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
1884                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
1885                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
1886                }
1887                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
1888                      sizeof(GTPTunnel_t));
1889             }
1890          }
1891          if(ulInfo->list.array[ulidx]!=NULLP)
1892          {
1893             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
1894          }
1895       }
1896       CU_FREE(ulInfo->list.array,ulInfo->list.size);
1897    }
1898 }
1899 /*******************************************************************
1900  *
1901  * @brief Deallocating memory for BuildAndSendUESetReq
1902  *
1903  * @details
1904  *
1905  *    Function : FreeDRBSetup
1906  *
1907  *    Functionality:  Deallocating memory for BuildDRBSetup
1908  *
1909  * @params[in] DRBs_ToBeSetup_List_t *drbSet
1910  *
1911  * @return void
1912  *
1913  * ****************************************************************/
1914 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
1915 {
1916    DRBs_ToBeSetup_Item_t *drbSetItem;
1917    uint8_t  flowidx;
1918    uint8_t  drbidx;
1919    if(drbSet->list.array == NULLP)
1920    {
1921       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
1922       {
1923          if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
1924          {
1925             drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
1926             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
1927             {
1928                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
1929                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
1930                {
1931                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
1932                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
1933                   {
1934                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
1935                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
1936                      {
1937                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
1938                         {
1939                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
1940                            {
1941                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
1942                               {
1943                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
1944                                        flows_Mapped_To_DRB_List.list.array != NULLP)
1945                                  {
1946                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
1947                                           flows_Mapped_To_DRB_List.list.count; flowidx++)
1948                                     {
1949                                        if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1950                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
1951                                        {
1952                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1953                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
1954                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
1955                                           {
1956                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1957                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
1958                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
1959                                              {
1960                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1961                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
1962                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
1963                                                 {
1964                                                    FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
1965                                                    CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
1966
1967                                                    CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1968                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
1969                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
1970                                                          sizeof(MaxDataBurstVolume_t));
1971                                                 }
1972                                                 CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1973                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
1974                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
1975                                              }
1976                                              CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1977                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
1978                                                    qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
1979                                           }
1980                                        }
1981                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1982                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
1983                                        {
1984                                           CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
1985                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
1986                                        }
1987                                     }
1988                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
1989                                           flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
1990                                           choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
1991                                  }
1992                                  CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
1993                                        drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
1994                               }
1995                               CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
1996                                     sizeof(OCTET_STRING_t));
1997                            }
1998                            CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
1999                                  drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
2000                         }
2001                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2002                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
2003                      }
2004                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2005                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2006                   }
2007                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2008                         qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
2009                }
2010                CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2011             }
2012          }
2013          if(drbSet->list.array[drbidx]!=NULLP)
2014          {
2015             CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2016          }
2017       }
2018       CU_FREE(drbSet->list.array,drbSet->list.size);
2019    }
2020 }
2021
2022
2023 /*******************************************************************
2024  *
2025  * @brief Free the UE Setup Request
2026  *
2027  * @details
2028  *
2029  *    Function : FreeUESetReq
2030  *
2031  *    Functionality: Deallocate the memory of BuildUESetReq
2032  *
2033  * @params[in]  F1AP_PDU_t  *f1apMsg
2034  *
2035  * @return void
2036  *
2037  *
2038  * ****************************************************************/
2039 void FreeUESetReq(F1AP_PDU_t  *f1apMsg)
2040 {
2041    uint8_t idx=2;
2042    uint8_t ieId;
2043    UEContextSetupRequest_t       *ueSetReq;
2044
2045    if(f1apMsg != NULLP)
2046    {
2047       if(f1apMsg->choice.initiatingMessage != NULLP)
2048       {
2049          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2050          if(ueSetReq->protocolIEs.list.array != NULLP)
2051          {
2052             if(ueSetReq->protocolIEs.list.array[idx])
2053             {
2054                FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2055                idx=6;
2056                if(ueSetReq->protocolIEs.list.array[idx])
2057                {
2058                   FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2059                   idx++;
2060                   if(ueSetReq->protocolIEs.list.array[idx])
2061                   {
2062                      FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2063                      idx++;
2064                      if(ueSetReq->protocolIEs.list.array[idx])
2065                      {
2066                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2067                      }
2068                   }
2069                }
2070             }
2071             for(ieId=0; ieId<ueSetReq->protocolIEs.list.count; ieId++)
2072             {
2073                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
2074                {
2075                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
2076                }
2077             }
2078             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2079          }
2080          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2081       }
2082       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2083    }
2084 }
2085
2086 /*******************************************************************
2087  *
2088  * @brief Builds and sends the UE Setup Request
2089  *
2090  * @details
2091  *
2092  *    Function : BuildAndSendUESetReq
2093  *
2094  *    Functionality: Constructs the UE Setup Request and sends
2095  *                   it to the CU through SCTP.
2096  *
2097  * @params[in]
2098  *
2099  * @return ROK     - success
2100  *         RFAILED - failure
2101  *
2102  * ****************************************************************/
2103 uint8_t BuildAndSendUESetReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
2104    uint16_t rrcContLen, uint8_t *rrcContainer)
2105 {
2106    uint8_t   Nrcgiret;
2107    uint8_t   SplCellListret;
2108    uint8_t   SrbSetupret;
2109    uint8_t   elementCnt;
2110    uint8_t   idx;
2111    uint8_t   idx1;
2112    F1AP_PDU_t           *f1apMsg = NULLP;
2113    UEContextSetupRequest_t *ueSetReq = NULLP;
2114    asn_enc_rval_t encRetVal;        /* Encoder return value */
2115    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2116    uint8_t ret= RFAILED;
2117    uint8_t ret1;
2118    while(1)
2119    {
2120       DU_LOG("\n F1AP : Building UE Context Setup Request\n");
2121
2122       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2123       if(f1apMsg == NULLP)
2124       {
2125          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
2126          break;
2127       }
2128
2129       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2130       CU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2131       if(f1apMsg->choice.initiatingMessage == NULLP)
2132       {
2133          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
2134          break;
2135       }
2136
2137       f1apMsg->choice.initiatingMessage->procedureCode = \
2138          ProcedureCode_id_UEContextSetup;
2139       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
2140       f1apMsg->choice.initiatingMessage->value.present = \
2141          InitiatingMessage__value_PR_UEContextSetupRequest;
2142       ueSetReq =
2143          &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2144
2145       elementCnt = 11;
2146       ueSetReq->protocolIEs.list.count = elementCnt;
2147       ueSetReq->protocolIEs.list.size = \
2148                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
2149
2150       /* Initialize the UESetup members */
2151       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2152
2153       if(ueSetReq->protocolIEs.list.array == NULLP)
2154       {
2155          DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
2156          break;
2157       }
2158
2159       for(idx1=0; idx1<elementCnt; idx1++)
2160       {
2161          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
2162          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
2163          {
2164             break;
2165          }
2166       }
2167
2168       idx = 0;
2169
2170       /*GNB CU UE F1AP ID*/
2171       ueSetReq->protocolIEs.list.array[idx]->id = \
2172                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2173       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2174       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2175                                                              UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
2176       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
2177
2178       /*GNB DU UE F1AP ID*/
2179       idx++;
2180       ueSetReq->protocolIEs.list.array[idx]->id = \
2181                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2182       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2183       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2184                                                              UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
2185       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
2186
2187       /*Special Cell ID*/
2188       idx++;
2189       ueSetReq->protocolIEs.list.array[idx]->id = \
2190                                                   ProtocolIE_ID_id_SpCell_ID;
2191       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2192       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2193                                                              UEContextSetupRequestIEs__value_PR_NRCGI;
2194       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2195       if(Nrcgiret != ROK)
2196       {
2197          break;
2198       }
2199
2200       /*Served Cell Index*/
2201       idx++;
2202       ueSetReq->protocolIEs.list.array[idx]->id = \
2203                                                   ProtocolIE_ID_id_ServCellIndex;
2204       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2205       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2206                                                              UEContextSetupRequestIEs__value_PR_ServCellIndex;
2207       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
2208                                                                           CELL_INDEX;
2209
2210       /*CellULConfigured*/
2211       idx++;
2212       ueSetReq->protocolIEs.list.array[idx]->id = \
2213                                                   ProtocolIE_ID_id_SpCellULConfigured;
2214       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2215       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2216                                                              UEContextSetupRequestIEs__value_PR_CellULConfigured;
2217       ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
2218                                                                              CellULConfigured_none;
2219
2220
2221       /*CUtoDURRCContainer*/
2222       idx++;
2223       ueSetReq->protocolIEs.list.array[idx]->id = \
2224                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
2225       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2226       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2227                                                              UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
2228
2229       /*Special Cells to be SetupList*/
2230       idx++;
2231       ueSetReq->protocolIEs.list.array[idx]->id = \
2232                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
2233       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
2234       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2235                                                              UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
2236       SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2237       if(SplCellListret != ROK)
2238       {
2239          break;
2240       }
2241       /*SRBs To Be Setup List*/
2242       idx++;
2243       ueSetReq->protocolIEs.list.array[idx]->id = \
2244                                                   ProtocolIE_ID_id_SRBs_ToBeSetup_List;
2245       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2246       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2247                                                              UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
2248       SrbSetupret =     BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2249       if(SrbSetupret != ROK)
2250       {
2251          break;
2252       }
2253       /*DRBs to Be Setup List*/
2254       idx++;
2255       ueSetReq->protocolIEs.list.array[idx]->id = \
2256                                                   ProtocolIE_ID_id_DRBs_ToBeSetup_List;
2257       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
2258       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2259                                                              UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
2260       ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2261       if(ret1 != ROK)
2262       {
2263          break;
2264       }
2265
2266       /* RRC Container */
2267       idx++;
2268       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
2269       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
2270       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2271          UEContextSetupRequestIEs__value_PR_RRCContainer;
2272       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = rrcContLen;
2273       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
2274           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2275       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
2276       {
2277          DU_LOG(" F1AP : Memory allocation for BuildAndSendUESetReq failed");
2278          break;
2279       }
2280       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
2281          rrcContainer, ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2282
2283       /* RRC delivery status request */
2284       idx++;
2285       ueSetReq->protocolIEs.list.array[idx]->id = \
2286          ProtocolIE_ID_id_RRCDeliveryStatusRequest;
2287       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
2288       ueSetReq->protocolIEs.list.array[idx]->value.present = \
2289          UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
2290       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
2291          RRCDeliveryStatusRequest_true;
2292
2293       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2294
2295       /* Encode the F1SetupRequest type as APER */
2296       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2297       encBufSize = 0;
2298       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2299             encBuf);
2300       /* Encode results */
2301       if(encRetVal.encoded == ENCODE_FAIL)
2302       {
2303          DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
2304                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2305          break;
2306       }
2307       else
2308       {
2309          DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
2310          for(int i=0; i< encBufSize; i++)
2311          {
2312             printf("%x",encBuf[i]);
2313          }
2314       }
2315
2316       /* Sending  msg  */
2317       if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)    !=      ROK)
2318       {
2319          DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
2320          break;
2321       }
2322       ret = ROK;
2323       break;
2324    }
2325    FreeUESetReq(f1apMsg);
2326
2327    return ret;
2328 }/* End of BuildAndSendUESetReq*/
2329
2330 uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
2331 {
2332    uint8_t idx;
2333    uint8_t ret =ROK;
2334    uint8_t cuUeF1apId, duUeF1apId;
2335    uint8_t *rrcContainer;
2336    uint16_t rrcContLen;
2337    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
2338
2339    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2340
2341    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
2342    {
2343       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
2344       {
2345          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
2346             {
2347                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
2348                break;
2349             }
2350          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2351             {
2352                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2353                break;
2354             }
2355          case ProtocolIE_ID_id_SRBID:
2356             break;
2357          case ProtocolIE_ID_id_RRCContainer:
2358             {
2359                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
2360                CU_ALLOC(rrcContainer, rrcContLen)
2361                if(!rrcContainer)
2362                {
2363                   DU_LOG("\nCU_STUB: Failed to allocated memory in procUlRrcMsg");
2364                   return RFAILED;
2365                }
2366                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
2367                      rrcContLen);
2368                break;
2369             }
2370
2371          default:
2372             DU_LOG("\n Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
2373             break;
2374       }
2375    }
2376    if(!ret)
2377       ret = BuildAndSendUESetReq(cuUeF1apId, duUeF1apId, rrcContLen, rrcContainer);
2378    return ret;
2379 }
2380 /*******************************************************************
2381  *
2382  * @brief Handles received F1AP message and sends back response
2383  *
2384  * @details
2385  *
2386  *    Function : F1APMsgHdlr
2387  *
2388  *    Functionality:
2389  *         - Decodes received F1AP control message
2390  *         - Prepares response message, encodes and sends to SCTP
2391  *
2392  * @params[in]
2393  * @return ROK     - success
2394  *         RFAILED - failure
2395  *
2396  * ****************************************************************/
2397 void F1APMsgHdlr(Buffer *mBuf)
2398 {
2399    int i;
2400    char *recvBuf;
2401    MsgLen copyCnt;
2402    MsgLen recvBufLen;
2403    F1AP_PDU_t *f1apMsg = NULLP;
2404    asn_dec_rval_t rval; /* Decoder return value */
2405    F1AP_PDU_t f1apasnmsg ;
2406
2407    DU_LOG("\nF1AP : Received F1AP message buffer");
2408    ODU_PRINT_MSG(mBuf, 0,0);
2409
2410    /* Copy mBuf into char array to decode it */
2411    ODU_FIND_MSG_LEN(mBuf, &recvBufLen);
2412    CU_ALLOC(recvBuf, (Size)recvBufLen);
2413
2414    if(recvBuf == NULLP)
2415    {
2416       DU_LOG("\nF1AP : Memory allocation failed");
2417       return;
2418    }
2419    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
2420    {
2421       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
2422       return;
2423    }
2424
2425    printf("\nF1AP : Received flat buffer to be decoded : ");
2426    for(i=0; i< recvBufLen; i++)
2427    {
2428       printf("%x",recvBuf[i]);
2429    }
2430
2431    /* Decoding flat buffer into F1AP messsage */
2432    f1apMsg = &f1apasnmsg;
2433    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
2434
2435    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
2436    CU_FREE(recvBuf, (Size)recvBufLen);
2437
2438    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2439    {
2440       DU_LOG("\nF1AP : ASN decode failed");
2441       return;
2442    }
2443    printf("\n");
2444    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2445
2446    switch(f1apMsg->present)
2447    {
2448       case F1AP_PDU_PR_initiatingMessage:
2449       {
2450          switch(f1apMsg->choice.initiatingMessage->value.present)
2451          {
2452             case InitiatingMessage__value_PR_F1SetupRequest:
2453             {
2454                DU_LOG("\nF1AP : F1 setup request received");
2455                BuildAndSendF1SetupRsp();
2456                break;
2457             }
2458
2459             case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
2460             {
2461                DU_LOG("\nF1AP : GNB-DU config update received");
2462                BuildAndSendDUUpdateAck();
2463                break;
2464             }
2465             case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
2466             {
2467                DU_LOG("\nF1AP : Received InitialULRRCMessageTransfer");
2468                procInitULRRCMsg(f1apMsg);
2469                break;
2470             }
2471             case InitiatingMessage__value_PR_ULRRCMessageTransfer:
2472             {
2473                DU_LOG("\nF1AP : Received ULRRCMessageTransfer");
2474                procUlRrcMsg(f1apMsg);
2475             }
2476             default:
2477             {
2478                DU_LOG("\nF1AP : Invalid type of intiating message [%d]",f1apMsg->choice.initiatingMessage->value.present);
2479                return;
2480             }
2481          }/* End of switch(initiatingMessage) */
2482          break;
2483       }
2484
2485    }/* End of switch(f1apMsg->present) */
2486
2487 } /* End of F1APMsgHdlr */
2488
2489 /**********************************************************************
2490   End of file
2491  **********************************************************************/