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("\nERROR  -->  E2AP: 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("\nERROR  -->  E2AP: 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("\nERROR  -->  E2AP : 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("\nERROR  -->  E2AP : 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("\nERROR  -->  E2AP : 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("\nERROR  -->  E2AP : received 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("\nINFO   -->  E2AP : Building E2 Setup Request\n");
 209    do
 210    {
 211       DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
 212       if(e2apMsg == NULLP)
 213       {
 214          DU_LOG("\nERROR  -->  E2AP : 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("\nERROR  -->  E2AP : 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("\nERROR  -->  E2AP : 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("\nERROR  -->  E2AP : 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("\nDEBUG   -->  E2AP : 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("\nERROR  -->  E2AP : 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("\nERROR  --> 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       return RFAILED;
 365    }
 366
 367    ricReqId->ricRequestorID = 1;
 368    ricReqId->ricInstanceID  = 1;
 369    return ROK;
 370 }
 371
 372 /*******************************************************************
 373  *
 374  * @brief Fills the mandatory RicAdmitted List Items
 375  *
 376  * @details
 377  *
 378  *    Function : fillRicAdmitList
 379  *
 380  *    Functionality: Fills the mandatory Ric Admitted List Items
 381  *
 382  * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
 383  * @return ROK     - success
 384  *         RFAILED - failure
 385  *
 386  * ****************************************************************/
 387
 388 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
 389 {
 390
 391    if(ricAdmitItems != NULLP)
 392    {
 393       ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
 394       ricAdmitItems->criticality = CriticalityE2_reject;
 395       ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
 396       ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
 397    }
 398    else
 399    {
 400       return RFAILED;
 401    }
 402    return ROK;
 403 }
 404 /*******************************************************************
 405  *
 406  * @brief Builds the mandatory RicAdmitted List Params
 407  *
 408  * @details
 409  *
 410  *    Function : BuildRicAdmitList
 411  *
 412  *    Functionality: Builds the mandatory Ric Admitted List Params
 413  *
 414  * @params[in] RICaction_Admitted_List_t *admitListPtr
 415  * @return ROK     - success
 416  *         RFAILED - failure
 417  *
 418  * ****************************************************************/
 419
 420 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
 421 {
 422    uint8_t idx ;
 423    uint8_t elementCnt;
 424    uint8_t ret= ROK;
 425    elementCnt = 1;
 426
 427    if(admitListPtr == NULLP)
 428    {
 429       DU_LOG("\nERROR  -->  E2AP : Memory allocation for RIC Admit List failed");
 430       ret = RFAILED;
 431    }
 432    else
 433    {
 434       admitListPtr->list.count = elementCnt;
 435       admitListPtr->list.size  = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
 436       DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
 437       if(admitListPtr->list.array == NULLP)
 438       {
 439          DU_LOG("\nERROR  -->  E2AP : Memory allocation for RIC Admit List failed");
 440          ret = RFAILED;
 441       }
 442       else
 443       {
 444          for(idx=0 ; idx<elementCnt ; idx++ )
 445          {
 446             DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
 447             if(admitListPtr->list.array[idx] == NULLP)
 448             {
 449                ret = RFAILED;
 450             }
 451          }
 452          if(ret != RFAILED)
 453          {
 454             idx=0;
 455             fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
 456          }
 457       }
 458    }
 459    return ret;
 460 }
 461 /*******************************************************************
 462  *
 463  * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
 464  *
 465  * @details
 466  *
 467  *    Function : FreeRicSubscriptionRsp
 468  *
 469  * Functionality:Free the RicSubscriptionRsp
 470  *
 471  * @param[in] E2AP_PDU_t *e2apRicMsg
 472  *
 473  * @return void
 474  *
 475  *
 476  ******************************************************************/
 477 void FreeRicSubscriptionRsp(E2AP_PDU_t  *e2apRicMsg)
 478 {
 479    RICsubscriptionResponse_t  *ricSubscriptionRsp= NULLP;
 480    uint8_t idx=0;
 481    uint8_t idx1=0;
 482    RICaction_Admitted_List_t *admitListPtr;
 483
 484    if(e2apRicMsg != NULLP)
 485    {
 486       if(e2apRicMsg->choice.successfulOutcome != NULLP)
 487       {
 488          ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
 489          if(ricSubscriptionRsp)
 490          {
 491             if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
 492             {
 493                for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
 494                {
 495                   if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
 496                   {
 497                      switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
 498                      {
 499                         case ProtocolIE_IDE2_id_RICrequestID:
 500                            break;
 501
 502                         case ProtocolIE_IDE2_id_RANfunctionID:
 503                            break;
 504
 505                         case ProtocolIE_IDE2_id_RICactions_Admitted:
 506                            {
 507                               admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
 508                                              array[idx]->value.choice.RICaction_Admitted_List;
 509                               if(admitListPtr->list.array != NULLP)
 510                               {
 511                                  for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
 512                                  {
 513                                     if(admitListPtr->list.array[idx1] != NULLP)
 514                                     {
 515                                        DU_FREE(admitListPtr->list.array[idx1],
 516                                              sizeof(RICaction_Admitted_ItemIEs_t));
 517                                     }
 518                                  }
 519                                  DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
 520                               }
 521                               break;
 522                            }
 523                         default:
 524                            break;
 525                      }
 526                      DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
 527                            sizeof(RICsubscriptionResponse_IEs_t));
 528                   }
 529                }
 530                DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
 531                      ricSubscriptionRsp->protocolIEs.list.size);
 532             }
 533          }
 534          DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
 535       }
 536       DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
 537    }
 538 }
 539 /*******************************************************************
 540  *
 541  * @brief Builds and Send the RicSubscriptionRsp
 542  *
 543  * @details
 544  *
 545  *    Function : BuildAndSendRicSubscriptionRsp
 546  *
 547  * functionality:Fills the RicSubscriptionRsp
 548  *
 549  * @return ROK     - success
 550  *         RFAILED - failure
 551  *
 552  ******************************************************************/
 553 uint8_t  FillRicSubscriptionRsp(RICsubscriptionResponse_t  *ricSubscriptionRsp )
 554 {
 555    uint8_t idx=0;
 556    uint8_t ret = ROK;
 557    uint8_t elementCnt = 0;
 558    uint8_t BuildRicRequestIdret=ROK;
 559    uint8_t BuildRicAdmitListret=ROK;
 560
 561    elementCnt=3;
 562    ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
 563    ricSubscriptionRsp->protocolIEs.list.size  = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
 564    DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
 565          ricSubscriptionRsp->protocolIEs.list.size);
 566    if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
 567    {
 568       DU_LOG("\nERROR  -->  E2AP : Memory allocation for FillRicSubscriptionRsp  failed");
 569       ret = RFAILED;
 570    }
 571    else
 572    {
 573       for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
 574       {
 575          DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
 576                sizeof(RICsubscriptionResponse_IEs_t));
 577          if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
 578          {
 579             ret = RFAILED;
 580          }
 581       }
 582       if(ret != RFAILED)
 583       {
 584
 585          idx=0;
 586          ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
 587          ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 588          ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
 589                                                                          RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 590          BuildRicRequestIdret =
 591             BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
 592          if(BuildRicRequestIdret != ROK)
 593          {
 594             ret = RFAILED;
 595          }
 596          else
 597          {
 598             idx++;
 599             ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
 600             ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 601             ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
 602                                                                             RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 603             ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
 604
 605             idx++;
 606             ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
 607             ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 608             ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
 609                                                                             RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
 610             BuildRicAdmitListret =
 611                BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
 612             if(BuildRicAdmitListret != ROK)
 613             {
 614                ret = RFAILED;
 615             }
 616          }
 617       }
 618    }
 619    return ret;
 620 }
 621 /*******************************************************************
 622  *
 623  * @brief Builds and Send the RicSubscriptionRsp
 624  *
 625  * @details
 626  *
 627  *    Function : BuildAndSendRicSubscriptionRsp
 628  *
 629  * Functionality:Fills the RicSubscriptionRsp
 630  *
 631  * @return ROK     - success
 632  *         RFAILED - failure
 633  *
 634  ******************************************************************/
 635
 636 uint8_t BuildAndSendRicSubscriptionRsp()
 637 {
 638
 639    E2AP_PDU_t         *e2apRicMsg = NULLP;
 640    RICsubscriptionResponse_t  *ricSubscriptionRsp=NULLP;
 641    asn_enc_rval_t     encRetVal;
 642    uint8_t ret = RFAILED;
 643    uint8_t FillRicricSubscriptionRspret;
 644
 645    while(true)
 646    {
 647       DU_LOG("\nINFO   -->  E2AP : Building RIC Subscription Response\n");
 648
 649       DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
 650       if(e2apRicMsg == NULLP)
 651       {
 652          DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2AP-PDU failed");
 653          break;
 654       }
 655       e2apRicMsg->present =  E2AP_PDU_PR_successfulOutcome;
 656       DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
 657       if(e2apRicMsg->choice.successfulOutcome == NULLP)
 658       {
 659          DU_LOG("\nERROR  -->  E2AP : Memory allocation for RIC subscription Response failed");
 660          break;
 661       }
 662
 663       e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
 664       e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
 665       e2apRicMsg->choice.successfulOutcome->value.present = \
 666                                                             SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
 667       ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
 668
 669       FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
 670       if(FillRicricSubscriptionRspret != ROK)
 671       {
 672          DU_LOG("\nERROR  -->  E2AP : Memory allocation for RICsubscriptionResponseIE failed");
 673          break;
 674       }
 675
 676       /* Prints the Msg formed */
 677       xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
 678
 679       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 680       encBufSize = 0;
 681       encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
 682             encBuf);
 683       if(encRetVal.encoded == ENCODE_FAIL)
 684       {
 685          DU_LOG("\nERROR  -->  E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
 686                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 687          break;
 688       }
 689       else
 690       {
 691          DU_LOG("\nDEBUG   -->  E2AP : Created APER encoded buffer for RIC subscription response \n");
 692          for(int i=0; i< encBufSize; i++)
 693          {
 694             printf("%x",encBuf[i]);
 695          }
 696       }
 697
 698       if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
 699       {
 700          DU_LOG("\nERROR  -->  E2AP : Sending RIC Subscription Response failed");
 701          break;
 702       }
 703
 704       ret = ROK;
 705       break;
 706
 707    }
 708    FreeRicSubscriptionRsp(e2apRicMsg);
 709
 710    return ret;
 711 }
 712 /******************************************************************
 713  *
 714  * @brief Processes E2 Setup Response sent by RIC
 715  *
 716  * @details
 717  *
 718  *    Function : procE2SetupRsp
 719  *
 720  *    Functionality: Processes E2 Setup Response sent by RIC
 721  *
 722  * @params[in] E2AP_PDU_t ASN decoded E2AP message
 723  * @return ROK     - success
 724  *         RFAILED - failure
 725  *
 726  * ****************************************************************/
 727 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
 728 {
 729    uint8_t idx;
 730    uint32_t recvBufLen;
 731    E2setupResponse_t *e2SetRspMsg;
 732
 733    DU_LOG("\nINFO   -->  E2AP : E2 Setup Response received");
 734    duCb.e2Status = TRUE; //Set E2 status as true
 735    e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
 736
 737    for(idx=0; idx<e2SetRspMsg->protocolIEs.list.count; idx++)
 738    {
 739       switch(e2SetRspMsg->protocolIEs.list.array[idx]->id)
 740       {
 741          case ProtocolIE_IDE2_id_GlobalRIC_ID:
 742             {
 743                /* To store the Ric Id Params */
 744                recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[idx]->value\
 745                      .choice.GlobalRIC_ID.pLMN_Identity.size);
 746                e2apMsgDb.plmn = NULLP;
 747                DU_ALLOC(e2apMsgDb.plmn, recvBufLen);
 748                if(e2apMsgDb.plmn)
 749                {
 750                   memcpy(e2apMsgDb.plmn, e2SetRspMsg->protocolIEs.list.array[idx]\
 751                         ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
 752                   free(e2SetRspMsg->protocolIEs.list.array[idx]->value.choice.\
 753                         GlobalRIC_ID.pLMN_Identity.buf);
 754                }
 755                bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID.ric_ID, &e2apMsgDb.ricId);
 756                free(e2SetRspMsg->protocolIEs.list.array[idx]->value.choice.\
 757                      GlobalRIC_ID.ric_ID.buf);
 758                /*TODO : e2apMsgDb.plmn memory to be deallocated after the usage */
 759                break;
 760             }
 761          default:
 762             DU_LOG("\nERROR  -->  E2AP : Invalid IE received in E2SetupRsp:%ld",
 763                   e2SetRspMsg->protocolIEs.list.array[idx]->id);
 764             break;
 765       }
 766       free(e2SetRspMsg->protocolIEs.list.array[idx]);
 767    }
 768    free(e2SetRspMsg->protocolIEs.list.array);
 769    return ROK;
 770 }
 771
 772 /******************************************************************
 773  *
 774  * @brief Processes RIC Subscription Req sent by RIC
 775  *
 776  * @details
 777  *
 778  *    Function : procRicSubsReq
 779  *
 780  *    Functionality: Processes E2 Setup Response sent by CU
 781  *
 782  * @params[in] E2AP_PDU_t ASN decoded E2AP message
 783  * @return ROK     - success
 784  *         RFAILED - failure
 785  *
 786  * ****************************************************************/
 787
 788 uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg)
 789 {
 790    uint8_t idx;
 791    uint8_t ied;
 792    uint8_t ret = ROK;
 793    uint32_t recvBufLen;
 794    RICsubscriptionRequest_t *ricSubsReq;
 795    RICaction_ToBeSetup_ItemIEs_t *actionItem;
 796
 797    DU_LOG("\nINFO   -->  E2AP : RIC Subscription request received");
 798    ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
 799
 800    for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
 801    {
 802       if(ricSubsReq->protocolIEs.list.array[idx])
 803       {
 804          switch(ricSubsReq->protocolIEs.list.array[idx]->id)
 805          {
 806             case ProtocolIE_IDE2_id_RICrequestID:
 807                {
 808                   e2apMsgDb.ricReqId = ricSubsReq->protocolIEs.list.array[idx]->\
 809                                        value.choice.RICrequestID.ricRequestorID;
 810                   e2apMsgDb.ricInstanceId = ricSubsReq->protocolIEs.list.array[idx]-> \
 811                                             value.choice.RICrequestID.ricInstanceID;
 812                   break;
 813                }
 814             case ProtocolIE_IDE2_id_RANfunctionID:
 815                {
 816                   e2apMsgDb.ranFuncId = ricSubsReq->protocolIEs.list.array[idx]-> \
 817                                         value.choice.RANfunctionID;
 818                   break;
 819                }
 820             case ProtocolIE_IDE2_id_RICsubscriptionDetails:
 821                {
 822                   recvBufLen = sizeof(ricSubsReq->protocolIEs.list.array[idx]->value\
 823                         .choice.RICsubscriptionDetails.ricEventTriggerDefinition.size);
 824                   e2apMsgDb.ricEventTrigger = NULLP;
 825                   DU_ALLOC(e2apMsgDb.ricEventTrigger, recvBufLen);
 826                   /*TODO : e2apMsgDb.ricEventTrigger memory to be deallocated after the usage */
 827                   if(e2apMsgDb.ricEventTrigger)
 828                   {
 829                      memcpy(e2apMsgDb.ricEventTrigger, ricSubsReq->protocolIEs.list.array[idx]\
 830                            ->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf, \
 831                            recvBufLen);
 832                      free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
 833                            RICsubscriptionDetails.ricEventTriggerDefinition.buf);
 834                   }
 835                   if(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
 836                         list.array)
 837                   {
 838                      actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\
 839                                  .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\
 840                                  .list.array[0];
 841
 842                      for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
 843                            RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++)
 844                      {
 845                         switch(actionItem->id)
 846                         {
 847                            case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
 848                               {
 849                                  e2apMsgDb.ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
 850                                  e2apMsgDb.ricActionType = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType;
 851                                  break;
 852                               }
 853                            default:
 854                               DU_LOG("\nERROR  -->  E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
 855                               break;
 856                         }
 857                         free(actionItem);
 858                      }
 859                      free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
 860                      list.array);
 861                   }
 862                   break;
 863                }
 864
 865             default:
 866                DU_LOG("\nERROR  -->  E2AP : Invalid IE received in RIC SubsReq:%ld",
 867                      ricSubsReq->protocolIEs.list.array[idx]->id);
 868                break;
 869          }
 870          free(ricSubsReq->protocolIEs.list.array[idx]);
 871       }
 872    }
 873    free(ricSubsReq->protocolIEs.list.array);
 874    ret = BuildAndSendRicSubscriptionRsp();
 875
 876    return ret;
 877 }
 878
 879 /*******************************************************************
 880  *
 881  * @brief Free the RicIndication Message
 882  *
 883  * @details
 884  *
 885  *    Function : FreeRicIndication
 886  *
 887  * Functionality: Free the RicIndication Message
 888  *
 889  * @return void
 890  *
 891  *
 892  ******************************************************************/
 893 void FreeRicIndication(E2AP_PDU_t  *e2apMsg)
 894 {
 895    uint8_t idx=0;
 896    RICindication_t *ricIndicationMsg= NULLP;
 897
 898
 899    if(e2apMsg != NULLP)
 900    {
 901       if(e2apMsg->choice.initiatingMessage != NULLP)
 902       {
 903          ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
 904          if(ricIndicationMsg!= NULLP)
 905          {
 906             if(ricIndicationMsg->protocolIEs.list.array != NULLP)
 907             {
 908                for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
 909                {
 910                   if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
 911                   {
 912                      switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
 913                      {
 914                         case ProtocolIE_IDE2_id_RICrequestID:
 915                            break;
 916
 917                         case ProtocolIE_IDE2_id_RANfunctionID:
 918                            break;
 919
 920                         case ProtocolIE_IDE2_id_RICactionID:
 921                            break;
 922
 923                         case ProtocolIE_IDE2_id_RICindicationType:
 924                            break;
 925
 926                         case ProtocolIE_IDE2_id_RICindicationHeader:
 927                            {
 928                               DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
 929                                     ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
 930                               break;
 931                            }
 932                         case ProtocolIE_IDE2_id_RICindicationMessage:
 933                            {
 934                               DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
 935                                     ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
 936                               break;
 937                            }
 938                         default:
 939                            break;
 940                      }
 941                      DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
 942                   }
 943                }
 944                DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
 945             }
 946          }
 947          DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
 948       }
 949       DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
 950    }
 951 }
 952 /*******************************************************************
 953  *
 954  * brief Fill the RicIndication Message
 955  *
 956  * @details
 957  *
 958  *    Function : FillRicIndication
 959  *
 960  * Functionality:Fills the RicIndication Message
 961  *
 962  * @return ROK     - success
 963  *         RFAILED - failure
 964  *
 965  ******************************************************************/
 966 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg)
 967 {
 968    uint8_t elementCnt=0;
 969    uint8_t idx=0;
 970    uint8_t ret = ROK;
 971    elementCnt = 6;
 972
 973    ricIndicationMsg->protocolIEs.list.count = elementCnt;
 974    ricIndicationMsg->protocolIEs.list.size  = elementCnt * sizeof(RICindication_t);
 975    /* Initialize the Ric Indication members */
 976    DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
 977          ricIndicationMsg->protocolIEs.list.size);
 978    if(ricIndicationMsg->protocolIEs.list.array == NULLP)
 979    {
 980       DU_LOG("\nERROR  -->  E2AP : Memory allocation for RICindicationIEs failed");
 981       ret = RFAILED;
 982    }
 983    else
 984    {
 985       for(idx=0; idx<elementCnt; idx++)
 986       {
 987          DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
 988                sizeof(RICindication_IEs_t));
 989          if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
 990          {
 991             DU_LOG("\nERROR  -->  E2AP : Memory allocation for RICindicationIEs failed");
 992             ret = RFAILED;
 993          }
 994       }
 995       if(ret != RFAILED)
 996       {
 997          idx = 0;
 998
 999          ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
1000          ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1001          ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1002                                                                         RICindication_IEs__value_PR_RICrequestID;
1003          ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =\
1004                                                                                                   e2apMsgDb.ricReqId;
1005          ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID =\
1006                                                                                                  e2apMsgDb.ricInstanceId;
1007
1008          idx++;
1009          ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
1010          ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1011          ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1012                                                                         RICindication_IEs__value_PR_RANfunctionID;
1013          ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID =
1014             e2apMsgDb.ranFuncId;
1015
1016          idx++;
1017          ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
1018          ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1019          ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1020                                                                         RICindication_IEs__value_PR_RICactionID;
1021          ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID =
1022             e2apMsgDb.ricActionId;
1023
1024          idx++;
1025          ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
1026          ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1027          ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1028                                                                         RICindication_IEs__value_PR_RICindicationType;
1029          ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType =
1030             e2apMsgDb.ricActionType;
1031
1032          idx++;
1033          ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
1034          ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1035          ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1036                                                                         RICindication_IEs__value_PR_RICindicationHeader;
1037          ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 *
1038             sizeof(uint8_t);
1039          DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\
1040                ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1041          if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
1042          {
1043             DU_LOG("\nERROR  -->  E2AP : Memory allocation for RICindicationIEs failed");
1044             ret = RFAILED;
1045          }
1046          else
1047          {
1048             buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1049                   ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf);
1050             idx++;
1051             /* TO BE CHANGED: RIC INDICATION DATA */
1052             /* For now filling a dummy octect data, need to tested with PRBs*/
1053             ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
1054             ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1055             ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1056                                                                            RICindication_IEs__value_PR_RICindicationMessage;
1057             ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 *
1058                sizeof(uint8_t);
1059             DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\
1060                   ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1061             if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
1062             {
1063                DU_LOG("\nERROR  -->  E2AP : Memory allocation for RICindicationIEs failed");
1064                ret = RFAILED;
1065             }
1066             else
1067             {
1068                buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1069                      ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf);
1070             }
1071          }
1072       }
1073    }
1074    return ret;
1075 }
1076
1077 /*******************************************************************
1078  *
1079  * @brief Builds and Send the RicIndication Message
1080  *
1081  * @details
1082  *
1083  *    Function : BuildAndSendRicIndication
1084  *
1085  * Functionality:Fills the RicIndication Message
1086  *
1087  * @return ROK     - success
1088  *         RFAILED - failure
1089  *
1090  ******************************************************************/
1091
1092 uint8_t BuildAndSendRicIndication()
1093 {
1094    E2AP_PDU_t                 *e2apMsg = NULLP;
1095    RICindication_t            *ricIndicationMsg=NULLP;
1096    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1097    uint8_t ret = RFAILED;
1098    uint8_t FillRicIndicationret = ROK;
1099
1100    while(true)
1101    {
1102       DU_LOG("\nINFO   -->  E2AP : Building RIC Indication Message\n");
1103
1104       DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1105       if(e2apMsg == NULLP)
1106       {
1107          DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2AP-PDU failed");
1108          break;
1109       }
1110
1111       e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1112       DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1113       if(e2apMsg->choice.initiatingMessage == NULLP)
1114       {
1115          DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2AP-PDU failed");
1116          break;
1117       }
1118       e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
1119       e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1120       e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
1121
1122       ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1123
1124       FillRicIndicationret = FillRicIndication(ricIndicationMsg);
1125       if(FillRicIndicationret != ROK)
1126       {
1127          break;
1128       }
1129       /* Prints the Msg formed */
1130       xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1131       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1132       encBufSize = 0;
1133       encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1134             encBuf);
1135       if(encRetVal.encoded == ENCODE_FAIL)
1136       {
1137          DU_LOG("\nERROR  -->  E2AP : Could not encode RIC Indication Message (at %s)\n",\
1138                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1139          break;
1140       }
1141       else
1142       {
1143          DU_LOG("\nDEBUG  -->  E2AP : Created APER encoded buffer for RIC Indication Message \n");
1144          for(int i=0; i< encBufSize; i++)
1145          {
1146             printf("%x",encBuf[i]);
1147          }
1148       }
1149
1150       if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1151       {
1152          DU_LOG("\nINFO   -->  E2AP : Sending RIC Indication Message");
1153
1154       }
1155       ret = ROK;
1156       break;
1157    }
1158    FreeRicIndication(e2apMsg);
1159    return ret;
1160 }
1161
1162 /*******************************************************************
1163  *
1164  * @brief Sends E2 msg over SCTP
1165  *
1166  * @details
1167  *
1168  *    Function : SendE2APMsg
1169  *
1170  *    Functionality: Sends E2 msg over SCTP
1171  *
1172  * @params[in] Region region
1173  *             Pool pool
1174  * @return ROK     - success
1175  *         RFAILED - failure
1176  *
1177  * ****************************************************************/
1178
1179 uint8_t SendE2APMsg(Region region, Pool pool)
1180 {
1181    Buffer *mBuf=NULLP;
1182
1183    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
1184    {
1185       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1186       {
1187          ODU_PRINT_MSG(mBuf, 0,0);
1188
1189          if(sctpSend(mBuf, E2_INTERFACE) != ROK)
1190          {
1191             DU_LOG("\nERROR  -->  E2AP : SCTP Send for E2  failed");
1192             ODU_PUT_MSG_BUF(mBuf);
1193             return RFAILED;
1194          }
1195       }
1196       else
1197       {
1198          DU_LOG("\nERROR  -->  E2AP : ODU_ADD_POST_MSG_MULT failed");
1199          ODU_PUT_MSG_BUF(mBuf);
1200          return RFAILED;
1201       }
1202       ODU_PUT_MSG_BUF(mBuf);
1203    }
1204    else
1205    {
1206       DU_LOG("\nERROR  -->  E2AP : Failed to allocate memory");
1207       return RFAILED;
1208    }
1209
1210    return ROK;
1211 } /* SendE2APMsg */
1212
1213 /*******************************************************************
1214  *
1215  * @brief Handles received E2AP message and sends back response
1216  *
1217  * @details
1218  *
1219  *    Function : E2APMsgHdlr
1220  *
1221  *    Functionality:
1222  *         - Decodes received E2AP control message
1223  *         - Prepares response message, encodes and sends to SCTP
1224  *
1225  * @params[in]
1226  * @return ROK     - success
1227  *         RFAILED - failure
1228  *
1229  * ****************************************************************/
1230 void E2APMsgHdlr(Buffer *mBuf)
1231 {
1232    int i =0;
1233    char *recvBuf = NULLP;
1234    MsgLen copyCnt =0;
1235    MsgLen recvBufLen =0;
1236    E2AP_PDU_t *e2apMsg = NULLP;
1237    asn_dec_rval_t rval ={0}; /* Decoder return value */
1238    E2AP_PDU_t e2apasnmsg={0} ;
1239
1240    DU_LOG("\nDEBUG   -->  E2AP : Received E2AP message buffer");
1241    ODU_PRINT_MSG(mBuf, 0,0);
1242
1243    /* Copy mBuf into char array to decode it */
1244    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
1245    DU_ALLOC(recvBuf, (Size)recvBufLen);
1246
1247    if(recvBuf == NULLP)
1248    {
1249       DU_LOG("\nERROR  -->  E2AP : Memory allocation failed");
1250       return;
1251    }
1252    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
1253    {
1254       DU_LOG("\nERROR  -->  E2AP : Failed while copying %d", copyCnt);
1255       return;
1256    }
1257
1258    printf("\nDEBUG   -->  E2AP : Received flat buffer to be decoded : ");
1259    for(i=0; i< recvBufLen; i++)
1260    {
1261       printf("%x",recvBuf[i]);
1262    }
1263
1264    /* Decoding flat buffer into E2AP messsage */
1265    e2apMsg = &e2apasnmsg;
1266    memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1267
1268    rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1269    DU_FREE(recvBuf, (Size)recvBufLen);
1270
1271    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1272    {
1273       DU_LOG("\nERROR  -->  E2AP : ASN decode failed");
1274       return;
1275    }
1276    printf("\n");
1277    xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1278
1279    switch(e2apMsg->present)
1280    {
1281       case E2AP_PDU_PR_successfulOutcome:
1282          {
1283             switch(e2apMsg->choice.successfulOutcome->value.present)
1284             {
1285                case SuccessfulOutcomeE2__value_PR_E2setupResponse:
1286                   {
1287                      if(!duCb.e2Status)
1288                      {
1289                         DU_LOG("\nDEBUG   -->  E2AP : Store E2 setup response Params");
1290                         procE2SetupRsp(e2apMsg);
1291                      }
1292                      break;
1293                   }
1294                default:
1295                   {
1296                      DU_LOG("\nERROR  -->  E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome  [%d]",\
1297                      e2apMsg->choice.successfulOutcome->value.present);
1298                      return;
1299                   }
1300             }/* End of switch(successfulOutcome) */
1301             free(e2apMsg->choice.successfulOutcome);
1302             break;
1303          }
1304       case E2AP_PDU_PR_initiatingMessage:
1305          {
1306             switch(e2apMsg->choice.initiatingMessage->value.present)
1307             {
1308                case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
1309                   {
1310                      if(procRicSubsReq(e2apMsg) == ROK)
1311                      {
1312                         BuildAndSendRicIndication();
1313                      }
1314                      break;
1315                   }
1316                default:
1317                   {
1318                      DU_LOG("\nERROR  -->  E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
1319                      e2apMsg->choice.initiatingMessage->value.present);
1320                      return;
1321                   }
1322             }/* End of switch(initiatingMessage) */
1323             free(e2apMsg->choice.initiatingMessage);
1324             break;
1325          }
1326       default:
1327          {
1328             DU_LOG("\nERROR  -->  E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
1329             return;
1330          }
1331          free(e2apMsg);
1332
1333    }/* End of switch(e2apMsg->present) */
1334
1335 } /* End of E2APMsgHdlr */
1336
1337 /**********************************************************************
1338   End of file
1339  **********************************************************************/