src/du_app/du_e2ap_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 #include "du_e2ap_msg_hdl.h"
  19 #include "du_mgr_main.h"
  20 #include "GlobalE2node-gNB-ID.h"
  21
  22 /* Global variable */
  23 DuCfgParams duCfgParam;
  24
  25 /*******************************************************************
  26  *
  27  * @brief Builds Global gNodeB Params
  28  *
  29  * @details
  30  *
  31  *    Function : BuildGlobalgNBId
  32  *
  33  *    Functionality: Building the Plmn and gNB id
  34  *
  35  * @params[in] GlobalE2node_gNB_ID_t *gNbId
  36  * @return ROK     - success
  37  *         RFAILED - failure
  38  *
  39  ******************************************************************/
  40
  41 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
  42 {
  43    uint8_t unused = 0;
  44    uint8_t byteSize = 4;
  45    uint8_t val = 1;
  46    uint8_t ret = ROK;
  47
  48    /* Allocate Buffer size */
  49    gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
  50    gNbId->global_gNB_ID.plmn_id.buf = NULLP;
  51    DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
  52    if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
  53    {
  54       DU_LOG("\nE2AP: Memory allocation failed for Plmn buffer");
  55       ret = RFAILED;
  56    }
  57    else
  58    {
  59       buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
  60          &gNbId->global_gNB_ID.plmn_id);
  61       /* fill gND Id */
  62       gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
  63       /* Allocate Buffer size */
  64       gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
  65       gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
  66       DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
  67          gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
  68       if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
  69       {
  70          DU_LOG("\nE2AP: Memory allocation failed for gnb buffer");
  71          ret = RFAILED;
  72       }
  73       else
  74       {
  75          fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, val);
  76       }
  77    }
  78    return ret;
  79 }
  80
  81 /*******************************************************************
  82  *
  83  * @brief Fills the initiating IE for E2 Setup Request
  84  *
  85  * @details
  86  *
  87  *    Function : fillE2SetupReq
  88  *
  89  * Functionality:Fills the Initiating message for
  90  *               E2SetupRequest
  91  *
  92  * @params[in] E2setupRequest_t *e2SetupReq,
  93  *             uint8_t *idx
  94  * @return ROK     - success
  95  *         RFAILED - failure
  96  *
  97  ******************************************************************/
  98
  99 uint8_t fillE2SetupReq(E2setupRequest_t **e2SetupReq, uint8_t *idx)
 100 {
 101    uint8_t elementCnt = 0;
 102    uint8_t idx2 = 0;
 103    uint8_t ret = ROK;
 104
 105    if(*e2SetupReq != NULLP)
 106    {
 107       elementCnt = 1;
 108       (*e2SetupReq)->protocolIEs.list.count = elementCnt;
 109       (*e2SetupReq)->protocolIEs.list.size = \
 110               elementCnt * sizeof(E2setupRequestIEs_t);
 111
 112       /* Initialize the E2Setup members */
 113       DU_ALLOC((*e2SetupReq)->protocolIEs.list.array, \
 114                (*e2SetupReq)->protocolIEs.list.size);
 115       if((*e2SetupReq)->protocolIEs.list.array == NULLP)
 116       {
 117          DU_LOG("\nE2AP : Memory allocation failed for array elements");
 118          ret = RFAILED;
 119       }
 120       else
 121       {
 122          for(*idx = 0; *idx < elementCnt; (*idx)++)
 123          {
 124             DU_ALLOC((*e2SetupReq)->protocolIEs.list.array[*idx],\
 125                sizeof(E2setupRequestIEs_t));
 126             if((*e2SetupReq)->protocolIEs.list.array[*idx] == NULLP)
 127             {
 128                DU_LOG("\nE2AP : Memory allocation failed for arrayidx [%d]", *idx);
 129                ret = RFAILED;
 130             }
 131             else
 132             {
 133                /* GlobalE2node_gNB_ID */
 134                (*e2SetupReq)->protocolIEs.list.array[idx2]->id = \
 135                       ProtocolIE_IDE2_id_GlobalE2node_ID;
 136                (*e2SetupReq)->protocolIEs.list.array[idx2]->criticality = \
 137                             CriticalityE2_reject;
 138                (*e2SetupReq)->protocolIEs.list.array[idx2]->value.present =\
 139                              E2setupRequestIEs__value_PR_GlobalE2node_ID;
 140                (*e2SetupReq)->protocolIEs.list.array[idx2]->value.choice.\
 141                   GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
 142
 143                DU_ALLOC((*e2SetupReq)->protocolIEs.list.array[idx2]->value.choice.\
 144                   GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
 145                if((*e2SetupReq)->protocolIEs.list.array[idx2]->value.choice.\
 146                   GlobalE2node_ID.choice.gNB == NULLP)
 147                {
 148                   DU_LOG("\nE2AP : Memory allocation failed for gNbId");
 149                   ret = RFAILED;
 150                }
 151                else
 152                {
 153                   ret = BuildGlobalgNBId((*e2SetupReq)->protocolIEs.list.array[idx2]->value.\
 154                      choice.GlobalE2node_ID.choice.gNB);
 155                   if(ret != ROK)
 156                   {
 157                      ret = RFAILED;
 158                   }
 159                }
 160
 161             }
 162          }
 163       }
 164     }
 165     else
 166     {
 167        ret = RFAILED;
 168        DU_LOG("\nE2AP : Passed e2SetupReq is NULL");
 169     }
 170     return ret;
 171 }
 172
 173 /*******************************************************************
 174  *
 175  * @brief Builds and Send the E2SetupRequest
 176  *
 177  * @details
 178  *
 179  *    Function : BuildAndSendE2SetupReq
 180  *
 181  * Functionality:Fills the E2SetupRequest
 182  *
 183  * @return ROK     - success
 184  *         RFAILED - failure
 185  *
 186  ******************************************************************/
 187
 188 uint8_t BuildAndSendE2SetupReq()
 189 {
 190    uint8_t idx = 0;
 191    uint8_t ret = ROK;
 192    E2AP_PDU_t        *e2apMsg = NULLP;
 193    E2setupRequest_t  *e2SetupReq = NULLP;
 194    asn_enc_rval_t     encRetVal;       /* Encoder return value */
 195
 196    DU_LOG("\nE2AP : Building E2 Setup Request\n");
 197    do
 198    {
 199       DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
 200       if(e2apMsg == NULLP)
 201       {
 202          DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
 203          break;
 204       }
 205       e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
 206       DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
 207       if(e2apMsg->choice.initiatingMessage == NULLP)
 208       {
 209          DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
 210          DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
 211          return RFAILED;
 212       }
 213       e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
 214       e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
 215       e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
 216       e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
 217
 218       ret = fillE2SetupReq(&e2SetupReq, &idx);
 219       if(ret != ROK)
 220       {
 221          DU_LOG("\nE2AP : fillE2SetupReq() failed");
 222          break;
 223       }
 224       /* Prints the Msg formed */
 225       xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
 226
 227       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
 228       encBufSize = 0;
 229       encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
 230                       encBuf);
 231       if(encRetVal.encoded == ENCODE_FAIL)
 232       {
 233          DU_LOG("\nE2AP : Could not encode E2SetupRequest structure (at %s)\n",\
 234             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 235          break;
 236       }
 237       else
 238       {
 239          DU_LOG("\nE2AP : Created APER encoded buffer for E2SetupRequest\n");
 240          for(int i=0; i< encBufSize; i++)
 241          {
 242             printf("%x",encBuf[i]);
 243          }
 244       }
 245       if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
 246       {
 247          DU_LOG("\nE2AP : Sending E2 Setup request failed");
 248       }
 249
 250     break;
 251    }while(1);
 252
 253    deAllocateE2SetupReqMsg(e2apMsg, e2SetupReq, idx);
 254    return ret;
 255 }/* End of BuildAndSendE2SetupReq */
 256
 257 /*******************************************************************
 258  *
 259  * @brief De Allocate E2 Setup Request Message
 260  *
 261  * @details
 262  *
 263  *    Function : deAllocateE2SetupReqMsg
 264  *
 265  *    Functionality: De-Allocating E2 Setup request Message
 266  *
 267  * @params[in] E2AP_PDU_t *e2apMsg
 268  *             E2setupRequest_t *e2SetupReq
 269  * @return ROK     - success
 270  *         RFAILED - failure
 271  *
 272  * ****************************************************************/
 273
 274 uint8_t deAllocateE2SetupReqMsg(E2AP_PDU_t *e2apMsg, \
 275    E2setupRequest_t *e2SetupReq, uint8_t idx)
 276 {
 277    uint8_t idx2;
 278    uint8_t ret = ROK;
 279    /* De-allocating Memory */
 280    if(e2apMsg != NULLP)
 281    {
 282       if(e2apMsg->choice.initiatingMessage != NULLP)
 283       {
 284          if(e2SetupReq->protocolIEs.list.array != NULLP)
 285          {
 286             for(idx2 = 0; idx2 < idx; idx2++)
 287             {
 288                if(e2SetupReq->protocolIEs.list.array[idx2] != NULLP)
 289                {
 290                   switch(e2SetupReq->protocolIEs.list.array[idx2]->id)
 291                   {
 292                      case ProtocolIE_IDE2_id_GlobalE2node_ID:
 293                      {
 294                         if(e2SetupReq->protocolIEs.list.array[idx2]->\
 295                              value.choice.GlobalE2node_ID.choice.gNB != NULLP)
 296                         {
 297                               GlobalE2node_gNB_ID_t *gNbId = NULLP;
 298                               gNbId = e2SetupReq->protocolIEs.list.array[idx2]->\
 299                                          value.choice.GlobalE2node_ID.choice.gNB;
 300                               if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
 301                               {
 302                                  if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf != NULLP)
 303                                  {
 304                                     DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
 305                                        gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
 306                                  }
 307                                  DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
 308                                             gNbId->global_gNB_ID.plmn_id.size);
 309                               }
 310                               DU_FREE(e2SetupReq->protocolIEs.list.array[idx2]->value.\
 311                                 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
 312                         }
 313                         DU_FREE(e2SetupReq->protocolIEs.list.array[idx2],\
 314                             sizeof(E2setupRequestIEs_t));
 315                         break;
 316                      }
 317                      default:
 318                         DU_LOG("\n E2AP: Invalid event at e2SetupRequet %ld ",\
 319                            (e2SetupReq->protocolIEs.list.array[idx2]->id));
 320                         break;
 321                   }
 322                }
 323             }
 324             DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
 325          }
 326          DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
 327       }
 328       DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
 329    }
 330    return ret;
 331 }
 332 /*******************************************************************
 333  *
 334  * @brief Builds Ric Request Id
 335  *
 336  * @details
 337  *
 338  *    Function : BuildRicRequestId
 339  *
 340  *    Functionality: Building the Ric Request Id
 341  *
 342  * @params[in] RICrequestID_t *ricReqId
 343  * @return ROK     - success
 344  *         RFAILED - failure
 345  *
 346  * ****************************************************************/
 347
 348 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
 349 {
 350    if(ricReqId != NULLP)
 351    {
 352       ricReqId->ricRequestorID = 1;
 353       ricReqId->ricInstanceID  = 1;
 354    }
 355         else
 356         {
 357            return RFAILED;
 358         }
 359    return ROK;
 360 }
 361
 362 /*******************************************************************
 363  *
 364  * @brief Fills the mandatory RicAdmitted List Items
 365  *
 366  * @details
 367  *
 368  *    Function : fillRicAdmitList
 369  *
 370  *    Functionality: Fills the mandatory Ric Admitted List Items
 371  *
 372  * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
 373  * @return ROK     - success
 374  *         RFAILED - failure
 375  *
 376  * ****************************************************************/
 377
 378 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
 379 {
 380
 381    if(ricAdmitItems != NULLP)
 382    {
 383       ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
 384       ricAdmitItems->criticality = CriticalityE2_reject;
 385       ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
 386       ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
 387    }
 388         else
 389         {
 390            return RFAILED;
 391         }
 392    return ROK;
 393 }
 394 /*******************************************************************
 395  *
 396  * @brief Builds the mandatory RicAdmitted List Params
 397  *
 398  * @details
 399  *
 400  *    Function : BuildRicAdmitList
 401  *
 402  *    Functionality: Builds the mandatory Ric Admitted List Params
 403  *
 404  * @params[in] RICaction_Admitted_List_t *admitListPtr
 405  * @return ROK     - success
 406  *         RFAILED - failure
 407  *
 408  * ****************************************************************/
 409
 410 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
 411 {
 412    uint8_t idx ;
 413    uint8_t elementCnt;
 414         uint8_t ret= ROK;
 415    elementCnt = 1;
 416
 417    if(admitListPtr == NULLP)
 418         {
 419             DU_LOG("\nE2AP : Memory allocation for RIC Admit List failed");
 420             ret = RFAILED;
 421         }
 422    else
 423         {
 424            admitListPtr->list.count = elementCnt;
 425       admitListPtr->list.size  = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
 426       DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
 427       if(admitListPtr->list.array == NULLP)
 428       {
 429          DU_LOG("\nE2AP : Memory allocation for RIC Admit List failed");
 430          ret = RFAILED;
 431       }
 432                 else
 433                 {
 434               for(idx=0 ; idx<elementCnt ; idx++ )
 435               {
 436             DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
 437                       if(admitListPtr->list.array[idx] == NULLP)
 438                       {
 439                          ret = RFAILED;
 440                       }
 441                         }
 442                         if(ret != RFAILED)
 443                         {
 444                  idx=0;
 445             fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
 446          }
 447                 }
 448         }
 449    return ret;
 450 }
 451 /*******************************************************************
 452  *
 453  * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
 454  *
 455  * @details
 456  *
 457  *    Function : FreeRicSubscriptionRsp
 458  *
 459  * Functionality:Free the RicSubscriptionRsp
 460  *
 461  * @param[in] E2AP_PDU_t *e2apRicMsg
 462  *
 463  * @return void
 464  *
 465  *
 466  ******************************************************************/
 467 void FreeRicSubscriptionRsp(E2AP_PDU_t  *e2apRicMsg)
 468 {
 469           RICsubscriptionResponse_t  *ricSubscriptionRsp= NULLP;
 470      uint8_t idx=0;
 471           uint8_t idx1=0;
 472           RICaction_Admitted_List_t *admitListPtr;
 473
 474           if(e2apRicMsg != NULLP)
 475           {
 476              if(e2apRicMsg->choice.successfulOutcome != NULLP)
 477                   {
 478                      ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
 479                           if(ricSubscriptionRsp)
 480                           {
 481                              if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
 482                                   {
 483                                      for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
 484                                           {
 485                                              if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
 486                                                   {
 487                                                      switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
 488                                                           {
 489                                                              case ProtocolIE_IDE2_id_RICrequestID:
 490                                                                        break;
 491
 492                                                                   case ProtocolIE_IDE2_id_RANfunctionID:
 493                                                                        break;
 494
 495                                                                   case ProtocolIE_IDE2_id_RICactions_Admitted:
 496                                                         {
 497                                                             admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
 498                                                                            array[idx]->value.choice.RICaction_Admitted_List;
 499                                                                            if(admitListPtr->list.array != NULLP)
 500                                                                            {
 501                                                                                for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
 502                                                                                {
 503                                                                                   if(admitListPtr->list.array[idx1] != NULLP)
 504                                                                    {
 505                                                                                          DU_FREE(admitListPtr->list.array[idx1],
 506                                                                                      sizeof(RICaction_Admitted_ItemIEs_t));
 507                                                                                             }
 508                                                                                }
 509                                                                                     DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
 510                                }
 511                                                                                  break;
 512                                                                     }
 513                                                                          default:
 514                                                                             break;
 515                         }
 516                                                       DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
 517                                                            sizeof(RICsubscriptionResponse_IEs_t));
 518                                                    }
 519                                            }
 520                                            DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
 521                                            ricSubscriptionRsp->protocolIEs.list.size);
 522                }
 523             }
 524                            DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
 525                    }
 526          DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
 527           }
 528 }
 529  /*******************************************************************
 530  *
 531  * @brief Builds and Send the RicSubscriptionRsp
 532  *
 533  * @details
 534  *
 535  *    Function : BuildAndSendRicSubscriptionRsp
 536  *
 537  * functionality:Fills the RicSubscriptionRsp
 538  *
 539  * @return ROK     - success
 540  *         RFAILED - failure
 541  *
 542  ******************************************************************/
 543 uint8_t  FillRicSubscriptionRsp(RICsubscriptionResponse_t  *ricSubscriptionRsp )
 544 {
 545    uint8_t idx=0;
 546         uint8_t ret = ROK;
 547         uint8_t elementCnt = 0;
 548         uint8_t BuildRicRequestIdret=ROK;
 549         uint8_t BuildRicAdmitListret=ROK;
 550
 551    elementCnt=3;
 552         ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
 553         ricSubscriptionRsp->protocolIEs.list.size  = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
 554    DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
 555         ricSubscriptionRsp->protocolIEs.list.size);
 556         if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
 557         {
 558       DU_LOG("\nE2AP : Memory allocation for FillRicSubscriptionRsp  failed");
 559                 ret = RFAILED;
 560         }
 561         else
 562         {
 563            for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
 564            {
 565               DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
 566                 sizeof(RICsubscriptionResponse_IEs_t));
 567                 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
 568                         {
 569                         ret = RFAILED;
 570                         }
 571                 }
 572                 if(ret != RFAILED)
 573                 {
 574
 575                         idx=0;
 576                 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
 577                 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 578                 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
 579                 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 580                 BuildRicRequestIdret =
 581                 BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
 582                 if(BuildRicRequestIdret != ROK)
 583                 {
 584                         ret = RFAILED;
 585                 }
 586               else
 587                         {
 588                                 idx++;
 589                                 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
 590                                 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 591                                 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
 592                                 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 593                                 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
 594
 595                                 idx++;
 596                                 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
 597                                 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 598                                 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
 599                                 RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
 600                                 BuildRicAdmitListret =
 601                                 BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
 602                                 if(BuildRicAdmitListret != ROK)
 603                                 {
 604                                 ret = RFAILED;
 605                                 }
 606                         }
 607                 }
 608         }
 609    return ret;
 610 }
 611 /*******************************************************************
 612  *
 613  * @brief Builds and Send the RicSubscriptionRsp
 614  *
 615  * @details
 616  *
 617  *    Function : BuildAndSendRicSubscriptionRsp
 618  *
 619  * Functionality:Fills the RicSubscriptionRsp
 620  *
 621  * @return ROK     - success
 622  *         RFAILED - failure
 623  *
 624  ******************************************************************/
 625
 626 uint8_t BuildAndSendRicSubscriptionRsp()
 627 {
 628
 629    E2AP_PDU_t         *e2apRicMsg = NULLP;
 630    RICsubscriptionResponse_t  *ricSubscriptionRsp=NULLP;
 631    asn_enc_rval_t     encRetVal;
 632    uint8_t ret = RFAILED;
 633    uint8_t FillRicricSubscriptionRspret;
 634
 635    while(1)
 636    {
 637         DU_LOG("\nE2AP : Building RIC Subscription Response\n");
 638
 639         DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
 640         if(e2apRicMsg == NULLP)
 641         {
 642            DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
 643            break;
 644         }
 645         e2apRicMsg->present =  E2AP_PDU_PR_successfulOutcome;
 646         DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
 647         if(e2apRicMsg->choice.successfulOutcome == NULLP)
 648         {
 649              DU_LOG("\nE2AP : Memory allocation for Ric subscription Response failed");
 650              break;
 651         }
 652
 653         e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
 654         e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
 655         e2apRicMsg->choice.successfulOutcome->value.present = \
 656          SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
 657         ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
 658
 659                   FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
 660         if(FillRicricSubscriptionRspret != ROK)
 661                   {
 662                      DU_LOG("\nE2AP : Memory allocation for RICsubscriptionResponseIE failed");
 663                      break;
 664                   }
 665
 666        /* Prints the Msg formed */
 667         xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
 668
 669         cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
 670         encBufSize = 0;
 671         encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
 672                encBuf);
 673         if(encRetVal.encoded == ENCODE_FAIL)
 674         {
 675                  DU_LOG("\nE2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
 676                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 677                  break;
 678         }
 679         else
 680         {
 681             DU_LOG("\nE2AP : Created APER encoded buffer for RIC subscription response \n");
 682                  for(int i=0; i< encBufSize; i++)
 683                  {
 684                           printf("%x",encBuf[i]);
 685                  }
 686         }
 687
 688         if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
 689         {
 690             DU_LOG("\nE2AP : Sending RIC Subscription Response failed");
 691             break;
 692         }
 693
 694                   ret = ROK;
 695                   break;
 696
 697     }
 698          FreeRicSubscriptionRsp(e2apRicMsg);
 699
 700          return ret;
 701  }
 702 /******************************************************************
 703 *
 704 * @brief Processes E2 Setup Response sent by RIC
 705 *
 706 * @details
 707 *
 708 *    Function : procE2SetupRsp
 709 *
 710 *    Functionality: Processes E2 Setup Response sent by RIC
 711 *
 712 * @params[in] E2AP_PDU_t ASN decoded E2AP message
 713 * @return ROK     - success
 714 *         RFAILED - failure
 715 *
 716 * ****************************************************************/
 717 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
 718 {
 719    uint8_t idx;
 720    uint32_t recvBufLen;
 721    E2setupResponse_t *e2SetRspMsg;
 722
 723    DU_LOG("\nE2AP : E2 Setup Response received");
 724    duCb.e2Status = TRUE; //Set E2 status as true
 725    e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
 726
 727    for(idx=0; idx<e2SetRspMsg->protocolIEs.list.count; idx++)
 728    {
 729       switch(e2SetRspMsg->protocolIEs.list.array[idx]->id)
 730       {
 731          case ProtocolIE_IDE2_id_GlobalRIC_ID:
 732          {
 733             /* To store the Ric Id Params */
 734             recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[idx]->value\
 735                                  .choice.GlobalRIC_ID.pLMN_Identity.size);
 736                                 e2apMsgDb.plmn = NULLP;
 737             DU_ALLOC(e2apMsgDb.plmn, recvBufLen);
 738                                 if(e2apMsgDb.plmn)
 739                                 {
 740                                    memcpy(e2apMsgDb.plmn, e2SetRspMsg->protocolIEs.list.array[idx]\
 741                                          ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
 742                                 }
 743             bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID.ric_ID, &e2apMsgDb.ricId);
 744             /*TODO : e2apMsgDb.plmn memory to be deallocated after the usage */
 745                            break;
 746          }
 747          default:
 748             DU_LOG("\nE2AP : Invalid IE received in E2SetupRsp:%ld",
 749                   e2SetRspMsg->protocolIEs.list.array[idx]->id);
 750             break;
 751       }
 752    }
 753    return ROK;
 754 }
 755
 756 /******************************************************************
 757 *
 758 * @brief Processes RIC Subscription Req sent by RIC
 759 *
 760 * @details
 761 *
 762 *    Function : procRicSubsReq
 763 *
 764 *    Functionality: Processes E2 Setup Response sent by CU
 765 *
 766 * @params[in] E2AP_PDU_t ASN decoded E2AP message
 767 * @return ROK     - success
 768 *         RFAILED - failure
 769 *
 770 * ****************************************************************/
 771
 772 uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg)
 773 {
 774    uint8_t idx;
 775    uint8_t ied;
 776    uint8_t ret = ROK;
 777    uint32_t recvBufLen;
 778    RICsubscriptionRequest_t *ricSubsReq;
 779    RICaction_ToBeSetup_ItemIEs_t *actionItem;
 780
 781    DU_LOG("\nE2AP : Ric Subscription request received");
 782    ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
 783
 784    for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
 785    {
 786       switch(ricSubsReq->protocolIEs.list.array[idx]->id)
 787       {
 788          case ProtocolIE_IDE2_id_RICrequestID:
 789          {
 790             e2apMsgDb.ricReqId = ricSubsReq->protocolIEs.list.array[idx]->\
 791                                    value.choice.RICrequestID.ricRequestorID;
 792             e2apMsgDb.ricInstanceId = ricSubsReq->protocolIEs.list.array[idx]-> \
 793                                        value.choice.RICrequestID.ricInstanceID;
 794             break;
 795          }
 796          case ProtocolIE_IDE2_id_RANfunctionID:
 797          {
 798             e2apMsgDb.ranFuncId = ricSubsReq->protocolIEs.list.array[idx]-> \
 799                                    value.choice.RANfunctionID;
 800             break;
 801          }
 802          case ProtocolIE_IDE2_id_RICsubscriptionDetails:
 803          {
 804                            recvBufLen = sizeof(ricSubsReq->protocolIEs.list.array[idx]->value\
 805                                  .choice.RICsubscriptionDetails.ricEventTriggerDefinition.size);
 806                            e2apMsgDb.ricEventTrigger = NULLP;
 807                                 DU_ALLOC(e2apMsgDb.ricEventTrigger, recvBufLen);
 808                                 /*TODO : e2apMsgDb.ricEventTrigger memory to be deallocated after the usage */
 809                                 if(e2apMsgDb.ricEventTrigger)
 810                                 {
 811                                    memcpy(e2apMsgDb.ricEventTrigger, ricSubsReq->protocolIEs.list.array[idx]\
 812                                          ->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf, \
 813                                          recvBufLen);
 814                            }
 815             actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\
 816                                  .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\
 817                                  .list.array[0];
 818
 819             for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
 820              RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++)
 821             {
 822                switch(actionItem->id)
 823                {
 824                   case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
 825                   {
 826                      e2apMsgDb.ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
 827                      e2apMsgDb.ricActionType = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType;
 828                      break;
 829                   }
 830                   default:
 831                      DU_LOG("\nE2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
 832                   break;
 833                }
 834             }
 835
 836             break;
 837          }
 838
 839          default:
 840             DU_LOG("\nE2AP : Invalid IE received in Ric SubsReq:%ld",
 841                   ricSubsReq->protocolIEs.list.array[idx]->id);
 842             break;
 843       }
 844    }
 845    ret = BuildAndSendRicSubscriptionRsp();
 846
 847    return ret;
 848 }
 849
 850  /*******************************************************************
 851  *
 852  * @brief Free the RicIndication Message
 853  *
 854  * @details
 855  *
 856  *    Function : FreeRicIndication
 857  *
 858  * Functionality: Free the RicIndication Message
 859  *
 860  * @return void
 861  *
 862  *
 863  ******************************************************************/
 864  void FreeRicIndication(E2AP_PDU_t  *e2apMsg)
 865  {
 866      uint8_t idx=0;
 867      RICindication_t *ricIndicationMsg= NULLP;
 868
 869
 870      if(e2apMsg != NULLP)
 871           {
 872               if(e2apMsg->choice.initiatingMessage != NULLP)
 873                         {
 874                                  ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
 875                             if(ricIndicationMsg!= NULLP)
 876                                  {
 877                                      if(ricIndicationMsg->protocolIEs.list.array != NULLP)
 878                                           {
 879                                               for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
 880                                               {
 881                                                        if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
 882                                                        {
 883                                                            switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
 884                                                                           {
 885                                                                               case ProtocolIE_IDE2_id_RICrequestID:
 886                                                                                              break;
 887
 888                                                                                         case ProtocolIE_IDE2_id_RANfunctionID:
 889                                                                                              break;
 890
 891                                                                                         case ProtocolIE_IDE2_id_RICactionID:
 892                                                                                              break;
 893
 894                                                                                         case ProtocolIE_IDE2_id_RICindicationType:
 895                                                                                              break;
 896
 897                                                                                         case ProtocolIE_IDE2_id_RICindicationHeader:
 898                                                                                         {
 899                                                                                             DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
 900                                                                                                  ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
 901                                                                                             break;
 902                                                                                         }
 903                                                                                         case ProtocolIE_IDE2_id_RICindicationMessage:
 904                                                                                         {
 905                                                                                             DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
 906                                                                                                  ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
 907                                                                                             break;
 908                                                                                         }
 909                                                                                         default:
 910                                                                                            break;
 911                                                                           }
 912                                                                           DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
 913                                                             }
 914                                               }
 915                                               DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
 916                                                 }
 917                                  }
 918                                  DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
 919                         }
 920               DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
 921           }
 922  }
 923  /*******************************************************************
 924   *
 925   * brief Fill the RicIndication Message
 926   *
 927   * @details
 928   *
 929   *    Function : FillRicIndication
 930   *
 931   * Functionality:Fills the RicIndication Message
 932   *
 933   * @return ROK     - success
 934   *         RFAILED - failure
 935   *
 936   ******************************************************************/
 937 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg)
 938 {
 939    uint8_t elementCnt=0;
 940    uint8_t idx=0;
 941    uint8_t ret = ROK;
 942    elementCnt = 6;
 943
 944         ricIndicationMsg->protocolIEs.list.count = elementCnt;
 945         ricIndicationMsg->protocolIEs.list.size  = elementCnt * sizeof(RICindication_t);
 946         /* Initialize the Ric Indication members */
 947         DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
 948         ricIndicationMsg->protocolIEs.list.size);
 949         if(ricIndicationMsg->protocolIEs.list.array == NULLP)
 950         {
 951             DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
 952             ret = RFAILED;
 953         }
 954    else
 955         {
 956            for(idx=0; idx<elementCnt; idx++)
 957       {
 958               DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
 959               sizeof(RICindication_IEs_t));
 960               if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
 961               {
 962                  DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
 963                  ret = RFAILED;
 964                         }
 965            }
 966                 if(ret != RFAILED)
 967                 {
 968          idx = 0;
 969
 970               ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
 971               ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 972               ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
 973                                                         RICindication_IEs__value_PR_RICrequestID;
 974               ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =\
 975                         e2apMsgDb.ricReqId;
 976               ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID =\
 977                         e2apMsgDb.ricInstanceId;
 978
 979               idx++;
 980               ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
 981               ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 982               ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
 983               RICindication_IEs__value_PR_RANfunctionID;
 984               ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID =
 985                         e2apMsgDb.ranFuncId;
 986
 987               idx++;
 988               ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
 989               ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 990               ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
 991                         RICindication_IEs__value_PR_RICactionID;
 992               ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID =
 993                         e2apMsgDb.ricActionId;
 994
 995               idx++;
 996               ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
 997               ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 998               ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
 999                         RICindication_IEs__value_PR_RICindicationType;
1000               ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType =
1001                         e2apMsgDb.ricActionType;
1002
1003                         idx++;
1004          ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
1005          ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1006               ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1007               RICindication_IEs__value_PR_RICindicationHeader;
1008               ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 *
1009               sizeof(uint8_t);
1010          DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\
1011               ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1012               if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
1013               {
1014                  DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
1015                  ret = RFAILED;
1016               }
1017                    else
1018                    {
1019                  buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1020                  &ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader);
1021                  idx++;
1022             /* TO BE CHANGED: RIC INDICATION DATA */
1023             /* For now filling a dummy octect data, need to tested with PRBs*/
1024             ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
1025             ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1026             ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1027             RICindication_IEs__value_PR_RICindicationMessage;
1028             ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 *
1029             sizeof(uint8_t);
1030             DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\
1031                         ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1032                                 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
1033                                 {
1034                                 DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
1035                         ret = RFAILED;
1036                         }
1037                                 else
1038                                 {
1039                                         buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1040                                         &ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage);
1041                                 }
1042                         }
1043                 }
1044         }
1045         return ret;
1046 }
1047
1048 /*******************************************************************
1049  *
1050  * @brief Builds and Send the RicIndication Message
1051  *
1052  * @details
1053  *
1054  *    Function : BuildAndSendRicIndication
1055  *
1056  * Functionality:Fills the RicIndication Message
1057  *
1058  * @return ROK     - success
1059  *         RFAILED - failure
1060  *
1061  ******************************************************************/
1062
1063 uint8_t BuildAndSendRicIndication()
1064 {
1065    E2AP_PDU_t                 *e2apMsg = NULLP;
1066    RICindication_t            *ricIndicationMsg=NULLP;
1067    uint8_t   elementCnt=0;
1068    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1069    uint8_t ret = RFAILED;
1070         uint8_t FillRicIndicationret = ROK;
1071
1072         while(1)
1073         {
1074         DU_LOG("\nE2AP : Building Ric Indication Message\n");
1075
1076         DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1077         if(e2apMsg == NULLP)
1078         {
1079              DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
1080              break;
1081         }
1082
1083         e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1084         DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1085         if(e2apMsg->choice.initiatingMessage == NULLP)
1086         {
1087              DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
1088              break;
1089         }
1090         e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
1091         e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1092         e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
1093
1094                   ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1095
1096                   FillRicIndicationret = FillRicIndication(ricIndicationMsg);
1097         if(FillRicIndicationret != ROK)
1098                   {
1099                       break;
1100                   }
1101                   /* Prints the Msg formed */
1102         xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1103         cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
1104                   encBufSize = 0;
1105         encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1106                encBuf);
1107         if(encRetVal.encoded == ENCODE_FAIL)
1108         {
1109                  DU_LOG("\nE2AP : Could not encode RIC Indication Message (at %s)\n",\
1110                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1111                  break;
1112         }
1113         else
1114         {
1115            DU_LOG("\nE2AP : Created APER encoded buffer for RIC Indication Message \n");
1116                 for(int i=0; i< encBufSize; i++)
1117                 {
1118                          printf("%x",encBuf[i]);
1119                 }
1120         }
1121
1122         if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1123         {
1124             DU_LOG("\nE2AP : Sending RIC Indication Message");
1125
1126         }
1127                   ret = ROK;
1128                   break;
1129    }
1130    FreeRicIndication(e2apMsg);
1131         return ret;
1132 }
1133
1134 /*******************************************************************
1135 *
1136 * @brief Sends E2 msg over SCTP
1137 *
1138 * @details
1139 *
1140 *    Function : SendE2APMsg
1141 *
1142 *    Functionality: Sends E2 msg over SCTP
1143 *
1144 * @params[in] Region region
1145 *             Pool pool
1146 * @return ROK     - success
1147 *         RFAILED - failure
1148 *
1149 * ****************************************************************/
1150
1151 uint8_t SendE2APMsg(Region region, Pool pool)
1152 {
1153    Buffer *mBuf=NULLP;
1154
1155    if(SGetMsg(region, pool, &mBuf) == ROK)
1156    {
1157       if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
1158       {
1159          SPrntMsg(mBuf, 0,0);
1160
1161          if(sctpSend(mBuf, E2_INTERFACE) != ROK)
1162          {
1163             DU_LOG("\nE2AP : SCTP Send for E2  failed");
1164             SPutMsg(mBuf);
1165             return RFAILED;
1166          }
1167       }
1168       else
1169       {
1170          DU_LOG("\nE2AP : SAddPstMsgMult failed");
1171          SPutMsg(mBuf);
1172          return RFAILED;
1173       }
1174       SPutMsg(mBuf);
1175    }
1176    else
1177    {
1178       DU_LOG("\nE2AP : Failed to allocate memory");
1179       return RFAILED;
1180    }
1181
1182    return ROK;
1183 } /* SendE2APMsg */
1184
1185 /*******************************************************************
1186 *
1187 * @brief Handles received E2AP message and sends back response
1188 *
1189 * @details
1190 *
1191 *    Function : E2APMsgHdlr
1192 *
1193 *    Functionality:
1194 *         - Decodes received E2AP control message
1195 *         - Prepares response message, encodes and sends to SCTP
1196 *
1197 * @params[in]
1198 * @return ROK     - success
1199 *         RFAILED - failure
1200 *
1201 * ****************************************************************/
1202 void E2APMsgHdlr(Buffer *mBuf)
1203 {
1204    int i;
1205    char *recvBuf;
1206    MsgLen copyCnt;
1207    MsgLen recvBufLen;
1208    E2AP_PDU_t *e2apMsg;
1209    asn_dec_rval_t rval; /* Decoder return value */
1210    E2AP_PDU_t e2apasnmsg ;
1211
1212    DU_LOG("\nE2AP : Received E2AP message buffer");
1213    SPrntMsg(mBuf, 0,0);
1214
1215    /* Copy mBuf into char array to decode it */
1216    SFndLenMsg(mBuf, &recvBufLen);
1217    if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
1218    {
1219       DU_LOG("\nE2AP : Memory allocation failed");
1220       return;
1221    }
1222    if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
1223    {
1224       DU_LOG("\nE2AP : Failed while copying %d", copyCnt);
1225       return;
1226    }
1227
1228    printf("\nE2AP : Received flat buffer to be decoded : ");
1229    for(i=0; i< recvBufLen; i++)
1230    {
1231         printf("%x",recvBuf[i]);
1232    }
1233
1234    /* Decoding flat buffer into E2AP messsage */
1235    e2apMsg = &e2apasnmsg;
1236    memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1237
1238    rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1239    SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
1240    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1241    {
1242       DU_LOG("\nE2AP : ASN decode failed");
1243       return;
1244    }
1245    printf("\n");
1246    xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1247
1248    switch(e2apMsg->present)
1249    {
1250       case E2AP_PDU_PR_successfulOutcome:
1251       {
1252          switch(e2apMsg->choice.successfulOutcome->value.present)
1253          {
1254             case SuccessfulOutcomeE2__value_PR_E2setupResponse:
1255             {
1256                if(!duCb.e2Status)
1257                {
1258                  DU_LOG("\nE2AP : Store E2 setup response Params");
1259                  procE2SetupRsp(e2apMsg);
1260                }
1261                break;
1262             }
1263             default:
1264             {
1265                DU_LOG("\nE2AP : Invalid type of intiating message [%d]", e2apMsg->choice.initiatingMessage->value.present);
1266                return;
1267             }
1268          }/* End of switch(successfulOutcome) */
1269          break;
1270       }
1271       case E2AP_PDU_PR_initiatingMessage:
1272       {
1273          switch(e2apMsg->choice.initiatingMessage->value.present)
1274          {
1275             case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
1276             {
1277                DU_LOG("\nE2AP : Calling RIC Subscription Response");
1278                if(procRicSubsReq(e2apMsg) == ROK)
1279                {
1280                   BuildAndSendRicIndication();
1281                }
1282                break;
1283             }
1284             default:
1285             {
1286                DU_LOG("\nE2AP : Invalid type of successfulOutcome message [%d]", e2apMsg->choice.successfulOutcome->value.present);
1287                return;
1288             }
1289          }/* End of switch(initiatingMessage) */
1290          break;
1291       }
1292       default:
1293       {
1294          DU_LOG("\nE2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
1295          return;
1296       }
1297
1298    }/* End of switch(e2apMsg->present) */
1299
1300 } /* End of E2APMsgHdlr */
1301
1302 /**********************************************************************
1303          End of file
1304 **********************************************************************/