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