1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
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 #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
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"
23 #include "du_app_mac_inf.h"
24 #include "du_app_rlc_inf.h"
27 #include "du_mgr_main.h"
29 #include "GlobalE2node-gNB-ID.h"
30 #include<ProtocolIE-FieldE2.h>
32 #include "du_e2ap_msg_hdl.h"
33 #include "odu_common_codec.h"
36 DuCfgParams duCfgParam;
37 /*******************************************************************
39 * @brief Builds Global gNodeB Params
43 * Function : BuildGlobalgNBId
45 * Functionality: Building the Plmn and gNB id
47 * @params[in] GlobalE2node_gNB_ID_t *gNbId
48 * @return ROK - success
51 ******************************************************************/
53 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
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)
66 DU_LOG("\nERROR --> E2AP: Memory allocation failed for Plmn buffer");
71 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
72 gNbId->global_gNB_ID.plmn_id.buf);
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)
82 DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
87 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, val);
93 /*******************************************************************
95 * @brief Fills the initiating IE for E2 Setup Request
99 * Function : fillE2SetupReq
101 * Functionality:Fills the Initiating message for
104 * @params[in] E2setupRequest_t *e2SetupReq,
106 * @return ROK - success
109 ******************************************************************/
111 uint8_t fillE2SetupReq(E2setupRequest_t **e2SetupReq, uint8_t *idx)
113 uint8_t elementCnt = 0;
117 if(*e2SetupReq != NULLP)
120 (*e2SetupReq)->protocolIEs.list.count = elementCnt;
121 (*e2SetupReq)->protocolIEs.list.size = \
122 elementCnt * sizeof(E2setupRequestIEs_t);
124 /* Initialize the E2Setup members */
125 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array, \
126 (*e2SetupReq)->protocolIEs.list.size);
127 if((*e2SetupReq)->protocolIEs.list.array == NULLP)
129 DU_LOG("\nERROR --> E2AP : Memory allocation failed for array elements");
134 for(*idx = 0; *idx < elementCnt; (*idx)++)
136 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array[*idx],\
137 sizeof(E2setupRequestIEs_t));
138 if((*e2SetupReq)->protocolIEs.list.array[*idx] == NULLP)
140 DU_LOG("\nERROR --> E2AP : Memory allocation failed for arrayidx [%d]", *idx);
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;
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)
160 DU_LOG("\nERROR --> E2AP : Memory allocation failed for gNbId");
165 ret = BuildGlobalgNBId((*e2SetupReq)->protocolIEs.list.array[idx2]->value.\
166 choice.GlobalE2node_ID.choice.gNB);
180 DU_LOG("\nERROR --> E2AP : received e2SetupReq is NULL");
185 /*******************************************************************
187 * @brief Builds and Send the E2SetupRequest
191 * Function : BuildAndSendE2SetupReq
193 * Functionality:Fills the E2SetupRequest
195 * @return ROK - success
198 ******************************************************************/
200 uint8_t BuildAndSendE2SetupReq()
204 E2AP_PDU_t *e2apMsg = NULLP;
205 E2setupRequest_t *e2SetupReq = NULLP;
206 asn_enc_rval_t encRetVal; /* Encoder return value */
208 DU_LOG("\nINFO --> E2AP : Building E2 Setup Request\n");
211 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
214 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
217 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
218 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
219 if(e2apMsg->choice.initiatingMessage == NULLP)
221 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
222 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
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;
230 ret = fillE2SetupReq(&e2SetupReq, &idx);
233 DU_LOG("\nERROR --> E2AP : fillE2SetupReq() failed");
236 /* Prints the Msg formed */
237 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
239 memset(encBuf, 0, ENC_BUF_MAX_LEN);
241 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
243 if(encRetVal.encoded == ENCODE_FAIL)
245 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupRequest structure (at %s)\n",\
246 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
251 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupRequest\n");
252 for(int i=0; i< encBufSize; i++)
254 printf("%x",encBuf[i]);
257 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
259 DU_LOG("\nERROR --> E2AP : Sending E2 Setup request failed");
265 deAllocateE2SetupReqMsg(e2apMsg, e2SetupReq, idx);
267 }/* End of BuildAndSendE2SetupReq */
269 /*******************************************************************
271 * @brief De Allocate E2 Setup Request Message
275 * Function : deAllocateE2SetupReqMsg
277 * Functionality: De-Allocating E2 Setup request Message
279 * @params[in] E2AP_PDU_t *e2apMsg
280 * E2setupRequest_t *e2SetupReq
281 * @return ROK - success
284 * ****************************************************************/
286 uint8_t deAllocateE2SetupReqMsg(E2AP_PDU_t *e2apMsg, \
287 E2setupRequest_t *e2SetupReq, uint8_t idx)
291 /* De-allocating Memory */
294 if(e2apMsg->choice.initiatingMessage != NULLP)
296 if(e2SetupReq->protocolIEs.list.array != NULLP)
298 for(idx2 = 0; idx2 < idx; idx2++)
300 if(e2SetupReq->protocolIEs.list.array[idx2] != NULLP)
302 switch(e2SetupReq->protocolIEs.list.array[idx2]->id)
304 case ProtocolIE_IDE2_id_GlobalE2node_ID:
306 if(e2SetupReq->protocolIEs.list.array[idx2]->\
307 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
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)
314 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf != NULLP)
316 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
317 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
319 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
320 gNbId->global_gNB_ID.plmn_id.size);
322 DU_FREE(e2SetupReq->protocolIEs.list.array[idx2]->value.\
323 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
325 DU_FREE(e2SetupReq->protocolIEs.list.array[idx2],\
326 sizeof(E2setupRequestIEs_t));
330 DU_LOG("\nERROR --> E2AP: Invalid event at e2SetupRequet %ld ",\
331 (e2SetupReq->protocolIEs.list.array[idx2]->id));
336 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
338 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
340 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
344 /*******************************************************************
346 * @brief Builds Ric Request Id
350 * Function : BuildRicRequestId
352 * Functionality: Building the Ric Request Id
354 * @params[in] RICrequestID_t *ricReqId
355 * @return ROK - success
358 * ****************************************************************/
360 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
362 if(ricReqId == NULLP)
367 ricReqId->ricRequestorID = 1;
368 ricReqId->ricInstanceID = 1;
372 /*******************************************************************
374 * @brief Fills the mandatory RicAdmitted List Items
378 * Function : fillRicAdmitList
380 * Functionality: Fills the mandatory Ric Admitted List Items
382 * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
383 * @return ROK - success
386 * ****************************************************************/
388 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
391 if(ricAdmitItems != NULLP)
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;
404 /*******************************************************************
406 * @brief Builds the mandatory RicAdmitted List Params
410 * Function : BuildRicAdmitList
412 * Functionality: Builds the mandatory Ric Admitted List Params
414 * @params[in] RICaction_Admitted_List_t *admitListPtr
415 * @return ROK - success
418 * ****************************************************************/
420 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
427 if(admitListPtr == NULLP)
429 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
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)
439 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC Admit List failed");
444 for(idx=0 ; idx<elementCnt ; idx++ )
446 DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
447 if(admitListPtr->list.array[idx] == NULLP)
455 fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
461 /*******************************************************************
463 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
467 * Function : FreeRicSubscriptionRsp
469 * Functionality:Free the RicSubscriptionRsp
471 * @param[in] E2AP_PDU_t *e2apRicMsg
476 ******************************************************************/
477 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
479 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
482 RICaction_Admitted_List_t *admitListPtr;
484 if(e2apRicMsg != NULLP)
486 if(e2apRicMsg->choice.successfulOutcome != NULLP)
488 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
489 if(ricSubscriptionRsp)
491 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
493 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
495 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
497 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
499 case ProtocolIE_IDE2_id_RICrequestID:
502 case ProtocolIE_IDE2_id_RANfunctionID:
505 case ProtocolIE_IDE2_id_RICactions_Admitted:
507 admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
508 array[idx]->value.choice.RICaction_Admitted_List;
509 if(admitListPtr->list.array != NULLP)
511 for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
513 if(admitListPtr->list.array[idx1] != NULLP)
515 DU_FREE(admitListPtr->list.array[idx1],
516 sizeof(RICaction_Admitted_ItemIEs_t));
519 DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
526 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
527 sizeof(RICsubscriptionResponse_IEs_t));
530 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
531 ricSubscriptionRsp->protocolIEs.list.size);
534 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
536 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
539 /*******************************************************************
541 * @brief Builds and Send the RicSubscriptionRsp
545 * Function : BuildAndSendRicSubscriptionRsp
547 * functionality:Fills the RicSubscriptionRsp
549 * @return ROK - success
552 ******************************************************************/
553 uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp )
557 uint8_t elementCnt = 0;
558 uint8_t BuildRicRequestIdret=ROK;
559 uint8_t BuildRicAdmitListret=ROK;
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)
568 DU_LOG("\nERROR --> E2AP : Memory allocation for FillRicSubscriptionRsp failed");
573 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
575 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
576 sizeof(RICsubscriptionResponse_IEs_t));
577 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
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)
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;
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)
621 /*******************************************************************
623 * @brief Builds and Send the RicSubscriptionRsp
627 * Function : BuildAndSendRicSubscriptionRsp
629 * Functionality:Fills the RicSubscriptionRsp
631 * @return ROK - success
634 ******************************************************************/
636 uint8_t BuildAndSendRicSubscriptionRsp()
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;
647 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Response\n");
649 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
650 if(e2apRicMsg == NULLP)
652 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
655 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
656 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
657 if(e2apRicMsg->choice.successfulOutcome == NULLP)
659 DU_LOG("\nERROR --> E2AP : Memory allocation for RIC subscription Response failed");
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;
669 FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
670 if(FillRicricSubscriptionRspret != ROK)
672 DU_LOG("\nERROR --> E2AP : Memory allocation for RICsubscriptionResponseIE failed");
676 /* Prints the Msg formed */
677 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
679 memset(encBuf, 0, ENC_BUF_MAX_LEN);
681 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
683 if(encRetVal.encoded == ENCODE_FAIL)
685 DU_LOG("\nERROR --> E2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
686 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
691 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC subscription response \n");
692 for(int i=0; i< encBufSize; i++)
694 printf("%x",encBuf[i]);
698 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
700 DU_LOG("\nERROR --> E2AP : Sending RIC Subscription Response failed");
708 FreeRicSubscriptionRsp(e2apRicMsg);
712 /******************************************************************
714 * @brief Processes E2 Setup Response sent by RIC
718 * Function : procE2SetupRsp
720 * Functionality: Processes E2 Setup Response sent by RIC
722 * @params[in] E2AP_PDU_t ASN decoded E2AP message
723 * @return ROK - success
726 * ****************************************************************/
727 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
731 E2setupResponse_t *e2SetRspMsg;
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;
737 for(idx=0; idx<e2SetRspMsg->protocolIEs.list.count; idx++)
739 switch(e2SetRspMsg->protocolIEs.list.array[idx]->id)
741 case ProtocolIE_IDE2_id_GlobalRIC_ID:
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);
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);
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 */
762 DU_LOG("\nERROR --> E2AP : Invalid IE received in E2SetupRsp:%ld",
763 e2SetRspMsg->protocolIEs.list.array[idx]->id);
766 free(e2SetRspMsg->protocolIEs.list.array[idx]);
768 free(e2SetRspMsg->protocolIEs.list.array);
772 /******************************************************************
774 * @brief Processes RIC Subscription Req sent by RIC
778 * Function : procRicSubsReq
780 * Functionality: Processes E2 Setup Response sent by CU
782 * @params[in] E2AP_PDU_t ASN decoded E2AP message
783 * @return ROK - success
786 * ****************************************************************/
788 uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg)
794 RICsubscriptionRequest_t *ricSubsReq;
795 RICaction_ToBeSetup_ItemIEs_t *actionItem;
797 DU_LOG("\nINFO --> E2AP : RIC Subscription request received");
798 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
800 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
802 if(ricSubsReq->protocolIEs.list.array[idx])
804 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
806 case ProtocolIE_IDE2_id_RICrequestID:
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;
814 case ProtocolIE_IDE2_id_RANfunctionID:
816 e2apMsgDb.ranFuncId = ricSubsReq->protocolIEs.list.array[idx]-> \
817 value.choice.RANfunctionID;
820 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
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)
829 memcpy(e2apMsgDb.ricEventTrigger, ricSubsReq->protocolIEs.list.array[idx]\
830 ->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf, \
832 free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
833 RICsubscriptionDetails.ricEventTriggerDefinition.buf);
835 if(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
838 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\
839 .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\
842 for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
843 RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++)
845 switch(actionItem->id)
847 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
849 e2apMsgDb.ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
850 e2apMsgDb.ricActionType = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType;
854 DU_LOG("\nERROR --> E2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
859 free(ricSubsReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.\
866 DU_LOG("\nERROR --> E2AP : Invalid IE received in RIC SubsReq:%ld",
867 ricSubsReq->protocolIEs.list.array[idx]->id);
870 free(ricSubsReq->protocolIEs.list.array[idx]);
873 free(ricSubsReq->protocolIEs.list.array);
874 ret = BuildAndSendRicSubscriptionRsp();
879 /*******************************************************************
881 * @brief Free the RicIndication Message
885 * Function : FreeRicIndication
887 * Functionality: Free the RicIndication Message
892 ******************************************************************/
893 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
896 RICindication_t *ricIndicationMsg= NULLP;
901 if(e2apMsg->choice.initiatingMessage != NULLP)
903 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
904 if(ricIndicationMsg!= NULLP)
906 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
908 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
910 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
912 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
914 case ProtocolIE_IDE2_id_RICrequestID:
917 case ProtocolIE_IDE2_id_RANfunctionID:
920 case ProtocolIE_IDE2_id_RICactionID:
923 case ProtocolIE_IDE2_id_RICindicationType:
926 case ProtocolIE_IDE2_id_RICindicationHeader:
928 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
929 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
932 case ProtocolIE_IDE2_id_RICindicationMessage:
934 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
935 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
941 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
944 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
947 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
949 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
952 /*******************************************************************
954 * brief Fill the RicIndication Message
958 * Function : FillRicIndication
960 * Functionality:Fills the RicIndication Message
962 * @return ROK - success
965 ******************************************************************/
966 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg)
968 uint8_t elementCnt=0;
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)
980 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
985 for(idx=0; idx<elementCnt; idx++)
987 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
988 sizeof(RICindication_IEs_t));
989 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
991 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
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 =\
1005 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID =\
1006 e2apMsgDb.ricInstanceId;
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;
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;
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;
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 *
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)
1043 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1048 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1049 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf);
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 *
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)
1063 DU_LOG("\nERROR --> E2AP : Memory allocation for RICindicationIEs failed");
1068 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1069 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf);
1077 /*******************************************************************
1079 * @brief Builds and Send the RicIndication Message
1083 * Function : BuildAndSendRicIndication
1085 * Functionality:Fills the RicIndication Message
1087 * @return ROK - success
1090 ******************************************************************/
1092 uint8_t BuildAndSendRicIndication()
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;
1102 DU_LOG("\nINFO --> E2AP : Building RIC Indication Message\n");
1104 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1105 if(e2apMsg == NULLP)
1107 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1111 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1112 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1113 if(e2apMsg->choice.initiatingMessage == NULLP)
1115 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
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;
1122 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1124 FillRicIndicationret = FillRicIndication(ricIndicationMsg);
1125 if(FillRicIndicationret != ROK)
1129 /* Prints the Msg formed */
1130 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1131 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1133 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1135 if(encRetVal.encoded == ENCODE_FAIL)
1137 DU_LOG("\nERROR --> E2AP : Could not encode RIC Indication Message (at %s)\n",\
1138 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1143 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC Indication Message \n");
1144 for(int i=0; i< encBufSize; i++)
1146 printf("%x",encBuf[i]);
1150 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1152 DU_LOG("\nINFO --> E2AP : Sending RIC Indication Message");
1158 FreeRicIndication(e2apMsg);
1162 /*******************************************************************
1164 * @brief Sends E2 msg over SCTP
1168 * Function : SendE2APMsg
1170 * Functionality: Sends E2 msg over SCTP
1172 * @params[in] Region region
1174 * @return ROK - success
1177 * ****************************************************************/
1179 uint8_t SendE2APMsg(Region region, Pool pool)
1183 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
1185 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1187 ODU_PRINT_MSG(mBuf, 0,0);
1189 if(sctpSend(mBuf, E2_INTERFACE) != ROK)
1191 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
1192 ODU_PUT_MSG_BUF(mBuf);
1198 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
1199 ODU_PUT_MSG_BUF(mBuf);
1202 ODU_PUT_MSG_BUF(mBuf);
1206 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
1213 /*******************************************************************
1215 * @brief Handles received E2AP message and sends back response
1219 * Function : E2APMsgHdlr
1222 * - Decodes received E2AP control message
1223 * - Prepares response message, encodes and sends to SCTP
1226 * @return ROK - success
1229 * ****************************************************************/
1230 void E2APMsgHdlr(Buffer *mBuf)
1233 char *recvBuf = NULLP;
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} ;
1240 DU_LOG("\nDEBUG --> E2AP : Received E2AP message buffer");
1241 ODU_PRINT_MSG(mBuf, 0,0);
1243 /* Copy mBuf into char array to decode it */
1244 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
1245 DU_ALLOC(recvBuf, (Size)recvBufLen);
1247 if(recvBuf == NULLP)
1249 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
1252 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
1254 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
1258 printf("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
1259 for(i=0; i< recvBufLen; i++)
1261 printf("%x",recvBuf[i]);
1264 /* Decoding flat buffer into E2AP messsage */
1265 e2apMsg = &e2apasnmsg;
1266 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1268 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1269 DU_FREE(recvBuf, (Size)recvBufLen);
1271 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1273 DU_LOG("\nERROR --> E2AP : ASN decode failed");
1277 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1279 switch(e2apMsg->present)
1281 case E2AP_PDU_PR_successfulOutcome:
1283 switch(e2apMsg->choice.successfulOutcome->value.present)
1285 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
1289 DU_LOG("\nDEBUG --> E2AP : Store E2 setup response Params");
1290 procE2SetupRsp(e2apMsg);
1296 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_successfulOutcome [%d]",\
1297 e2apMsg->choice.successfulOutcome->value.present);
1300 }/* End of switch(successfulOutcome) */
1301 free(e2apMsg->choice.successfulOutcome);
1304 case E2AP_PDU_PR_initiatingMessage:
1306 switch(e2apMsg->choice.initiatingMessage->value.present)
1308 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
1310 if(procRicSubsReq(e2apMsg) == ROK)
1312 BuildAndSendRicIndication();
1318 DU_LOG("\nERROR --> E2AP : Invalid type of E2AP_PDU_PR_initiatingMessage [%d]",\
1319 e2apMsg->choice.initiatingMessage->value.present);
1322 }/* End of switch(initiatingMessage) */
1323 free(e2apMsg->choice.initiatingMessage);
1328 DU_LOG("\nERROR --> E2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
1333 }/* End of switch(e2apMsg->present) */
1335 } /* End of E2APMsgHdlr */
1337 /**********************************************************************
1339 **********************************************************************/