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