src/ric_stub/ric_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
  19 /* This file contains E2AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "ric_stub_sctp.h"
  25 #include "ric_stub.h"
  26 #include "ric_e2ap_msg_hdl.h"
  27 #include "GlobalE2node-gNB-ID.h"
  28 #include "ProtocolIE-FieldE2.h"
  29 #include "InitiatingMessageE2.h"
  30 #include "SuccessfulOutcomeE2.h"
  31 #include "E2AP-PDU.h"
  32 #include "du_log.h"
  33
  34 Bool ricSubsStatus;
  35
  36 /*******************************************************************
  37 *
  38 * @brief Sends E2 msg over SCTP
  39 *
  40 * @details
  41 *
  42 *    Function : SendE2APMsg
  43 *
  44 *    Functionality: Sends E2 msg over SCTP
  45 *
  46 * @params[in] Region region
  47 *             Pool pool
  48 * @return ROK     - success
  49 *         RFAILED - failure
  50 *
  51 * ****************************************************************/
  52
  53 S16 SendE2APMsg(Region region, Pool pool)
  54 {
  55    Buffer *mBuf;
  56
  57    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
  58    {
  59       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
  60       {
  61          ODU_PRINT_MSG(mBuf, 0,0);
  62
  63          if(sctpSend(mBuf) != ROK)
  64          {
  65             DU_LOG("\nERROR  -->  E2AP : SCTP Send for E2  failed");
  66             ODU_PUT_MSG_BUF(mBuf);
  67             return RFAILED;
  68          }
  69       }
  70       else
  71       {
  72          DU_LOG("\nERROR  -->  E2AP : ODU_ADD_POST_MSG_MULT failed");
  73          ODU_PUT_MSG_BUF(mBuf);
  74          return RFAILED;
  75       }
  76       ODU_PUT_MSG_BUF(mBuf);
  77    }
  78    else
  79    {
  80       DU_LOG("\nERROR  -->  E2AP : Failed to allocate memory");
  81       return RFAILED;
  82    }
  83
  84    return ROK;
  85 } /* SendE2APMsg */
  86
  87 /*******************************************************************
  88  *
  89  * @brief Builds Global RIC Id Params
  90  *
  91  * @details
  92  *
  93  *    Function : BuildGlobalRicId
  94  *
  95  *    Functionality: Building the Plmn and ric id
  96  *
  97  * @params[in] GlobalRIC_ID_t *ricId
  98  * @return ROK     - success
  99  *         RFAILED - failure
 100  *
 101  * ****************************************************************/
 102
 103 S16 BuildGlobalRicId(GlobalRIC_ID_t *ricId)
 104 {
 105    uint8_t unused = 4;
 106    uint8_t byteSize = 3;
 107    uint8_t val = 16;
 108    if(ricId != NULLP)
 109    {
 110       ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
 111       RIC_ALLOC(ricId->pLMN_Identity.buf,  ricId->pLMN_Identity.size);
 112       buildPlmnId(ricCfgParams.plmn , ricId->pLMN_Identity.buf);
 113       /* fill ric Id */
 114       ricId->ric_ID.size = byteSize * sizeof(uint8_t);
 115       RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
 116       fillBitString(&ricId->ric_ID, unused, byteSize, val);
 117    }
 118    return ROK;
 119 }
 120
 121 /*******************************************************************
 122  *
 123  * @brief Builds and sends the E2SetupResponse
 124  *
 125  * @details
 126  *
 127  *    Function : BuildAndSendE2SetupRsp
 128  *
 129  *    Functionality: Constructs the F1SetupResponse message and sends
 130  *                   it back to the DU through SCTP.
 131  *
 132  * @params[in] void **buf,Buffer to which encoded pattern is written into
 133  * @params[in] int *size,size of buffer
 134  *
 135  * @return ROK     - success
 136  *         RFAILED - failure
 137  *
 138  * ****************************************************************/
 139 S16 BuildAndSendE2SetupRsp()
 140 {
 141    E2AP_PDU_t         *e2apMsg = NULL;
 142    E2setupResponse_t  *e2SetupRsp;
 143    asn_enc_rval_t     encRetVal;
 144    uint8_t            idx;
 145    uint8_t            elementCnt;
 146
 147
 148    DU_LOG("\nINFO   -->  E2AP : Building E2 Setup Response\n");
 149
 150    RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
 151    if(e2apMsg == NULLP)
 152    {
 153       DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2AP-PDU failed");
 154       return RFAILED;
 155    }
 156    e2apMsg->present =  E2AP_PDU_PR_successfulOutcome;
 157    RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
 158    if(e2apMsg->choice.successfulOutcome == NULLP)
 159    {
 160       DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2AP-PDU failed");
 161       RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
 162       return RFAILED;
 163    }
 164
 165    e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
 166    e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
 167    e2apMsg->choice.successfulOutcome->value.present = \
 168          SuccessfulOutcomeE2__value_PR_E2setupResponse;
 169    e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
 170
 171    elementCnt = 1;
 172    e2SetupRsp->protocolIEs.list.count = elementCnt;
 173    e2SetupRsp->protocolIEs.list.size  = elementCnt * sizeof(E2setupResponseIEs_t);
 174
 175    RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, \
 176               e2SetupRsp->protocolIEs.list.size);
 177    if(e2SetupRsp->protocolIEs.list.array == NULLP)
 178    {
 179       DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2ResponseIEs failed");
 180       RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
 181       RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
 182       return RFAILED;
 183    }
 184
 185    for(idx=0; idx<elementCnt; idx++)
 186    {
 187       RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], \
 188             sizeof(E2setupResponseIEs_t));
 189       if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
 190       {
 191          RIC_FREE(e2SetupRsp->protocolIEs.list.array,\
 192                    e2SetupRsp->protocolIEs.list.size);
 193          RIC_FREE(e2apMsg->choice.successfulOutcome, \
 194                sizeof(SuccessfulOutcomeE2_t));
 195          RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
 196          return RFAILED;
 197       }
 198    }
 199    /* Global RIC ID */
 200    idx = 0;
 201    e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
 202    e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 203    e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
 204                                      E2setupResponseIEs__value_PR_GlobalRIC_ID;
 205
 206    BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID));
 207
 208    xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
 209    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 210    encBufSize = 0;
 211    encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
 212
 213    /* Check encode results */
 214    if(encRetVal.encoded == ENCODE_FAIL)
 215    {
 216            DU_LOG("\nERROR  -->  E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
 217                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 218            return RFAILED;
 219    }
 220    else
 221    {
 222            DU_LOG("\nDEBUG  -->  E2AP : Created APER encoded buffer for E2SetupResponse\n");
 223            for(int i=0; i< encBufSize; i++)
 224            {
 225                    DU_LOG("%x",encBuf[i]);
 226            }
 227    }
 228
 229
 230    if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL) != ROK)
 231    {
 232       DU_LOG("\nERROR  -->  E2AP : Sending E2 Setup Response failed");
 233       return RFAILED;
 234    }
 235
 236    return ROK;
 237 }
 238
 239 /*******************************************************************
 240  *
 241  * @brief Builds Ric Request Id
 242  *
 243  * @details
 244  *
 245  *    Function : BuildRicRequestId
 246  *
 247  *    Functionality: Building the Ric Request Id
 248  *
 249  * @params[in] RICrequestID_t *ricReqId
 250  * @return ROK     - success
 251  *         RFAILED - failure
 252  *
 253  * ****************************************************************/
 254
 255 S16 BuildRicRequestId(RICrequestID_t *ricReqId)
 256 {
 257
 258    if(ricReqId != NULLP)
 259    {
 260       ricReqId->ricRequestorID = 1;
 261       ricReqId->ricInstanceID  = 1;
 262    }
 263    return ROK;
 264 }
 265
 266 /*******************************************************************
 267  *
 268  * @brief Fills Ric Action To be Setup Item
 269  *
 270  * @details
 271  *
 272  *    Function : fillSetupItems
 273  *
 274  *    Functionality: Filling ricAction Id, RicActionType
 275  *
 276  * @params[in] RICaction_ToBeSetup_Item_t *setupItems
 277  * @return pointer of type RICaction_ToBeSetup_Item_t
 278  *
 279  * ****************************************************************/
 280
 281 RICaction_ToBeSetup_Item_t* fillSetupItems(RICaction_ToBeSetup_Item_t *setupItems)
 282 {
 283    if(setupItems != NULLP)
 284    {
 285       setupItems->ricActionID = 0;
 286       setupItems->ricActionType = RICactionType_report;
 287    }
 288
 289    return (setupItems);
 290 }
 291
 292 /*******************************************************************
 293  *
 294  * @brief Fills RIC Subscription Details Item List
 295  *
 296  * @details
 297  *
 298  *    Function : fillSubsDetails
 299  *
 300  *    Functionality: Fill the RIC Subscription Details Items List
 301  *
 302  * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
 303  * @return ROK     - success
 304  *         RFAILED - failure
 305  *
 306  * ****************************************************************/
 307
 308 S16 fillSubsDetails(RICaction_ToBeSetup_ItemIEs_t *items)
 309 {
 310    if(items != NULLP)
 311    {
 312       items->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
 313       items->criticality   =  CriticalityE2_ignore;
 314       items->value.present =  RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
 315       fillSetupItems(&(items->value.choice.RICaction_ToBeSetup_Item));
 316    }
 317    return ROK;
 318 }
 319
 320 /*******************************************************************
 321  *
 322  * @brief builds RIC Subscription Details
 323  *
 324  * @details
 325  *
 326  *    Function : BuildsRicSubsDetails
 327  *
 328  *    Functionality: Builds the RIC Subscription Details
 329  *
 330  * @params[in] RICsubscriptionDetails_t *subsDetails
 331  * @return ROK     - success
 332  *         RFAILED - failure
 333  *
 334  * ****************************************************************/
 335
 336 S16 BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
 337 {
 338
 339    uint8_t elementCnt;
 340
 341    if(subsDetails != NULLP)
 342    {
 343       /* Octet string to be build here */
 344       /* Sending PLMN as Octect string */
 345       uint8_t byteSize = 3;
 346       subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(uint8_t);
 347       RIC_ALLOC(subsDetails->ricEventTriggerDefinition.buf,  subsDetails->ricEventTriggerDefinition.size);
 348       buildPlmnId(ricCfgParams.plmn, subsDetails->ricEventTriggerDefinition.buf);
 349       elementCnt = 1;
 350       subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
 351       subsDetails->ricAction_ToBeSetup_List.list.size = \
 352                       elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t);
 353       RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, \
 354                 subsDetails->ricAction_ToBeSetup_List.list.size);
 355       if(subsDetails->ricAction_ToBeSetup_List.list.array  == NULLP)
 356       {
 357          DU_LOG("\nERROR  -->  E2AP : Memory allocation for RICactionToBeSetup Items failed");
 358          return RFAILED;
 359       }
 360       RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[0],\
 361                    sizeof(RICaction_ToBeSetup_ItemIEs_t));
 362       fillSubsDetails(subsDetails->ricAction_ToBeSetup_List.list.array[0]);
 363    }
 364    return ROK;
 365 }
 366
 367 /*******************************************************************
 368  *
 369  * @brief Builds and Send the RicSubscriptionReq
 370  *
 371  * @details
 372  *
 373  *    Function : BuildAndSendRicSubscriptionReq
 374  *
 375  * Functionality:Fills the RicSubscriptionReq
 376  *
 377  * @return ROK     - success
 378  *         RFAILED - failure
 379  *
 380  ******************************************************************/
 381
 382 S16 BuildAndSendRicSubscriptionReq()
 383 {
 384
 385    E2AP_PDU_t                 *e2apRicMsg = NULL;
 386    RICsubscriptionRequest_t   *ricSubscriptionReq;
 387    uint8_t         elementCnt;
 388    uint8_t         idx;
 389    uint8_t         ieId;
 390    S16             ret;
 391    asn_enc_rval_t  encRetVal;        /* Encoder return value */
 392    ricSubsStatus = TRUE;
 393
 394    DU_LOG("\nINFO   -->  E2AP : Building RIC Subscription Request\n");
 395
 396    RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
 397    if(e2apRicMsg == NULLP)
 398    {
 399       DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2AP-PDU failed");
 400       return RFAILED;
 401    }
 402
 403    e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
 404    RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
 405    if(e2apRicMsg->choice.initiatingMessage == NULLP)
 406    {
 407       DU_LOG("\nERROR  -->  E2AP : Memory allocation for E2AP-PDU failed");
 408       RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
 409       return RFAILED;
 410    }
 411    e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
 412    e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
 413    e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
 414
 415    RIC_ALLOC(ricSubscriptionReq, sizeof(RICsubscriptionRequest_t));
 416    ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
 417
 418    elementCnt = 3;
 419    ricSubscriptionReq->protocolIEs.list.count = elementCnt;
 420    ricSubscriptionReq->protocolIEs.list.size  = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
 421
 422    /* Initialize the subscription members */
 423    RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, \
 424               ricSubscriptionReq->protocolIEs.list.size);
 425    if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
 426    {
 427       DU_LOG("\nERROR  -->  E2AP : Memory allocation for RICSubscriptionRequestIEs failed");
 428       RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
 429       RIC_FREE(e2apRicMsg, (Size)sizeof(E2AP_PDU_t));
 430       return RFAILED;
 431    }
 432
 433    for(idx=0; idx<elementCnt; idx++)
 434    {
 435       RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx],\
 436             sizeof(RICsubscriptionRequest_IEs_t));
 437       if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
 438       {
 439          for(ieId=0; ieId<idx; ieId++)
 440          {
 441             RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[ieId],\
 442                   sizeof(RICsubscriptionRequest_IEs_t));
 443          }
 444          RIC_FREE(ricSubscriptionReq->protocolIEs.list.array,\
 445                   ricSubscriptionReq->protocolIEs.list.size);
 446          RIC_FREE(e2apRicMsg->choice.initiatingMessage, \
 447                sizeof(InitiatingMessageE2_t));
 448          RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
 449          return RFAILED;
 450       }
 451    }
 452
 453    /* Filling RIC Request Id */
 454    idx = 0;
 455    ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
 456    ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 457    ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
 458                                     RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 459
 460    BuildRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID);
 461
 462
 463    /* Filling RAN Function Id */
 464    idx++;
 465    ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
 466    ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 467    ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
 468                                     RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 469    ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
 470
 471
 472    /* Filling RIC Subscription Details */
 473    idx++;
 474    ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
 475    ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
 476    ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
 477                                     RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
 478
 479    BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
 480
 481
 482    /* Prints the Msg formed */
 483    xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
 484
 485    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 486    encBufSize = 0;
 487    encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
 488                encBuf);
 489    if(encRetVal.encoded == ENCODE_FAIL)
 490    {
 491       DU_LOG("\nERROR  -->  E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
 492       encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 493       return RFAILED;
 494    }
 495    else
 496    {
 497       DU_LOG("\nDEBUG  -->  E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
 498       for(int i=0; i< encBufSize; i++)
 499       {
 500           DU_LOG("%x",encBuf[i]);
 501       }
 502    }
 503
 504
 505    /* Sending msg */
 506    if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL) != ROK)
 507    {
 508       DU_LOG("\nERROR  -->  E2AP : Sending RIC subscription Request failed");
 509       return RFAILED;
 510    }
 511
 512    return ROK;
 513 }
 514
 515
 516 /*******************************************************************
 517 *
 518 * @brief Handles received E2AP message and sends back response
 519 *
 520 * @details
 521 *
 522 *    Function : E2APMsgHdlr
 523 *
 524 *    Functionality:
 525 *         - Decodes received E2AP control message
 526 *         - Prepares response message, encodes and sends to SCTP
 527 *
 528 * @params[in]
 529 * @return ROK     - success
 530 *         RFAILED - failure
 531 *
 532 * ****************************************************************/
 533 void E2APMsgHdlr(Buffer *mBuf)
 534 {
 535    int             i;
 536    char            *recvBuf;
 537    MsgLen          copyCnt;
 538    MsgLen          recvBufLen;
 539    E2AP_PDU_t      *e2apMsg;
 540    asn_dec_rval_t  rval; /* Decoder return value */
 541    E2AP_PDU_t      e2apasnmsg ;
 542
 543    DU_LOG("\nINFO  -->  E2AP : Received E2AP message buffer");
 544    ODU_PRINT_MSG(mBuf, 0,0);
 545
 546    /* Copy mBuf into char array to decode it */
 547    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
 548    RIC_ALLOC(recvBuf, (Size)recvBufLen);
 549
 550    if(recvBuf == NULLP)
 551    {
 552       DU_LOG("\nERROR  -->  E2AP : Memory allocation failed");
 553       return;
 554    }
 555    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
 556    {
 557       DU_LOG("\nERROR  -->  E2AP : Failed while copying %d", copyCnt);
 558       return;
 559    }
 560
 561    DU_LOG("\nDEBUG  -->  E2AP : Received flat buffer to be decoded : ");
 562    for(i=0; i< recvBufLen; i++)
 563    {
 564         DU_LOG("%x",recvBuf[i]);
 565    }
 566
 567    /* Decoding flat buffer into E2AP messsage */
 568    e2apMsg = &e2apasnmsg;
 569    memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
 570
 571    rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
 572    RIC_FREE(recvBuf, (Size)recvBufLen);
 573
 574    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
 575    {
 576       DU_LOG("\nERROR  -->  E2AP : ASN decode failed");
 577       return;
 578    }
 579    DU_LOG("\n");
 580    xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
 581
 582    switch(e2apMsg->present)
 583    {
 584       case E2AP_PDU_PR_initiatingMessage:
 585       {
 586          switch(e2apMsg->choice.initiatingMessage->value.present)
 587          {
 588             case InitiatingMessageE2__value_PR_E2setupRequest:
 589             {
 590                DU_LOG("\nINFO  -->  E2AP : E2 setup request received");
 591                BuildAndSendE2SetupRsp();
 592                break;
 593             }
 594             case InitiatingMessageE2__value_PR_RICindication:
 595             {
 596                DU_LOG("\nINFO  -->  E2AP : RIC Indication Acknowledged");
 597                break;
 598             }
 599             default:
 600             {
 601                DU_LOG("\nERROR  -->  E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present);
 602                return;
 603             }
 604          }/* End of switch(initiatingMessage) */
 605          break;
 606       }
 607       case E2AP_PDU_PR_successfulOutcome:
 608       {
 609          switch(e2apMsg->choice.successfulOutcome->value.present)
 610          {
 611             case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
 612             {
 613                DU_LOG("\nINFO  -->  E2AP : RICsubscriptionResponse Msg Acknowledged");
 614                break;
 615             }
 616             default:
 617             {
 618                DU_LOG("\nERROR  -->  E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present);
 619                return;
 620             }
 621             break;
 622          }
 623          break;
 624       }
 625       default:
 626       {
 627          DU_LOG("\nERROR  -->  E2AP : Invalid type message type ");
 628          return;
 629       }
 630
 631     }/* End of switch(e2apMsg->present) */
 632
 633     if(!ricSubsStatus)
 634       BuildAndSendRicSubscriptionReq();
 635
 636 } /* End of E2APMsgHdlr */
 637
 638
 639 /**********************************************************************
 640   End of file
 641  **********************************************************************/