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