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