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"
24 #include "du_mgr_main.h"
25 #include "GlobalE2node-gNB-ID.h"
26 #include "odu_common_codec.h"
27 #include<ProtocolIE-FieldE2.h>
29 #include "du_e2ap_msg_hdl.h"
32 DuCfgParams duCfgParam;
33 /*******************************************************************
35 * @brief Builds Global gNodeB Params
39 * Function : BuildGlobalgNBId
41 * Functionality: Building the Plmn and gNB id
43 * @params[in] GlobalE2node_gNB_ID_t *gNbId
44 * @return ROK - success
47 ******************************************************************/
49 uint8_t BuildGlobalgNBId(GlobalE2node_gNB_ID_t *gNbId)
56 /* Allocate Buffer size */
57 gNbId->global_gNB_ID.plmn_id.size = 3 * sizeof(uint8_t);
58 gNbId->global_gNB_ID.plmn_id.buf = NULLP;
59 DU_ALLOC(gNbId->global_gNB_ID.plmn_id.buf , gNbId->global_gNB_ID.plmn_id.size);
60 if(gNbId->global_gNB_ID.plmn_id.buf == NULLP)
62 DU_LOG("\nE2AP: Memory allocation failed for Plmn buffer");
67 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
68 &gNbId->global_gNB_ID.plmn_id);
70 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
71 /* Allocate Buffer size */
72 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
73 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
74 DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
75 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
76 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
78 DU_LOG("\nE2AP: Memory allocation failed for gnb buffer");
83 fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, val);
89 /*******************************************************************
91 * @brief Fills the initiating IE for E2 Setup Request
95 * Function : fillE2SetupReq
97 * Functionality:Fills the Initiating message for
100 * @params[in] E2setupRequest_t *e2SetupReq,
102 * @return ROK - success
105 ******************************************************************/
107 uint8_t fillE2SetupReq(E2setupRequest_t **e2SetupReq, uint8_t *idx)
109 uint8_t elementCnt = 0;
113 if(*e2SetupReq != NULLP)
116 (*e2SetupReq)->protocolIEs.list.count = elementCnt;
117 (*e2SetupReq)->protocolIEs.list.size = \
118 elementCnt * sizeof(E2setupRequestIEs_t);
120 /* Initialize the E2Setup members */
121 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array, \
122 (*e2SetupReq)->protocolIEs.list.size);
123 if((*e2SetupReq)->protocolIEs.list.array == NULLP)
125 DU_LOG("\nE2AP : Memory allocation failed for array elements");
130 for(*idx = 0; *idx < elementCnt; (*idx)++)
132 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array[*idx],\
133 sizeof(E2setupRequestIEs_t));
134 if((*e2SetupReq)->protocolIEs.list.array[*idx] == NULLP)
136 DU_LOG("\nE2AP : Memory allocation failed for arrayidx [%d]", *idx);
141 /* GlobalE2node_gNB_ID */
142 (*e2SetupReq)->protocolIEs.list.array[idx2]->id = \
143 ProtocolIE_IDE2_id_GlobalE2node_ID;
144 (*e2SetupReq)->protocolIEs.list.array[idx2]->criticality = \
145 CriticalityE2_reject;
146 (*e2SetupReq)->protocolIEs.list.array[idx2]->value.present =\
147 E2setupRequestIEs__value_PR_GlobalE2node_ID;
148 (*e2SetupReq)->protocolIEs.list.array[idx2]->value.choice.\
149 GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
151 DU_ALLOC((*e2SetupReq)->protocolIEs.list.array[idx2]->value.choice.\
152 GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
153 if((*e2SetupReq)->protocolIEs.list.array[idx2]->value.choice.\
154 GlobalE2node_ID.choice.gNB == NULLP)
156 DU_LOG("\nE2AP : Memory allocation failed for gNbId");
161 ret = BuildGlobalgNBId((*e2SetupReq)->protocolIEs.list.array[idx2]->value.\
162 choice.GlobalE2node_ID.choice.gNB);
176 DU_LOG("\nE2AP : Passed e2SetupReq is NULL");
181 /*******************************************************************
183 * @brief Builds and Send the E2SetupRequest
187 * Function : BuildAndSendE2SetupReq
189 * Functionality:Fills the E2SetupRequest
191 * @return ROK - success
194 ******************************************************************/
196 uint8_t BuildAndSendE2SetupReq()
200 E2AP_PDU_t *e2apMsg = NULLP;
201 E2setupRequest_t *e2SetupReq = NULLP;
202 asn_enc_rval_t encRetVal; /* Encoder return value */
204 DU_LOG("\nE2AP : Building E2 Setup Request\n");
207 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
210 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
213 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
214 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
215 if(e2apMsg->choice.initiatingMessage == NULLP)
217 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
218 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
221 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
222 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
223 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
224 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
226 ret = fillE2SetupReq(&e2SetupReq, &idx);
229 DU_LOG("\nE2AP : fillE2SetupReq() failed");
232 /* Prints the Msg formed */
233 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
235 cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
237 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
239 if(encRetVal.encoded == ENCODE_FAIL)
241 DU_LOG("\nE2AP : Could not encode E2SetupRequest structure (at %s)\n",\
242 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
247 DU_LOG("\nE2AP : Created APER encoded buffer for E2SetupRequest\n");
248 for(int i=0; i< encBufSize; i++)
250 printf("%x",encBuf[i]);
253 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
255 DU_LOG("\nE2AP : Sending E2 Setup request failed");
261 deAllocateE2SetupReqMsg(e2apMsg, e2SetupReq, idx);
263 }/* End of BuildAndSendE2SetupReq */
265 /*******************************************************************
267 * @brief De Allocate E2 Setup Request Message
271 * Function : deAllocateE2SetupReqMsg
273 * Functionality: De-Allocating E2 Setup request Message
275 * @params[in] E2AP_PDU_t *e2apMsg
276 * E2setupRequest_t *e2SetupReq
277 * @return ROK - success
280 * ****************************************************************/
282 uint8_t deAllocateE2SetupReqMsg(E2AP_PDU_t *e2apMsg, \
283 E2setupRequest_t *e2SetupReq, uint8_t idx)
287 /* De-allocating Memory */
290 if(e2apMsg->choice.initiatingMessage != NULLP)
292 if(e2SetupReq->protocolIEs.list.array != NULLP)
294 for(idx2 = 0; idx2 < idx; idx2++)
296 if(e2SetupReq->protocolIEs.list.array[idx2] != NULLP)
298 switch(e2SetupReq->protocolIEs.list.array[idx2]->id)
300 case ProtocolIE_IDE2_id_GlobalE2node_ID:
302 if(e2SetupReq->protocolIEs.list.array[idx2]->\
303 value.choice.GlobalE2node_ID.choice.gNB != NULLP)
305 GlobalE2node_gNB_ID_t *gNbId = NULLP;
306 gNbId = e2SetupReq->protocolIEs.list.array[idx2]->\
307 value.choice.GlobalE2node_ID.choice.gNB;
308 if(gNbId->global_gNB_ID.plmn_id.buf != NULLP)
310 if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf != NULLP)
312 DU_FREE(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf,\
313 gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
315 DU_FREE(gNbId->global_gNB_ID.plmn_id.buf,\
316 gNbId->global_gNB_ID.plmn_id.size);
318 DU_FREE(e2SetupReq->protocolIEs.list.array[idx2]->value.\
319 choice.GlobalE2node_ID.choice.gNB, sizeof(GlobalE2node_gNB_ID_t));
321 DU_FREE(e2SetupReq->protocolIEs.list.array[idx2],\
322 sizeof(E2setupRequestIEs_t));
326 DU_LOG("\n E2AP: Invalid event at e2SetupRequet %ld ",\
327 (e2SetupReq->protocolIEs.list.array[idx2]->id));
332 DU_FREE(e2SetupReq->protocolIEs.list.array, e2SetupReq->protocolIEs.list.size);
334 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
336 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
340 /*******************************************************************
342 * @brief Builds Ric Request Id
346 * Function : BuildRicRequestId
348 * Functionality: Building the Ric Request Id
350 * @params[in] RICrequestID_t *ricReqId
351 * @return ROK - success
354 * ****************************************************************/
356 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
358 if(ricReqId != NULLP)
360 ricReqId->ricRequestorID = 1;
361 ricReqId->ricInstanceID = 1;
370 /*******************************************************************
372 * @brief Fills the mandatory RicAdmitted List Items
376 * Function : fillRicAdmitList
378 * Functionality: Fills the mandatory Ric Admitted List Items
380 * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
381 * @return ROK - success
384 * ****************************************************************/
386 uint8_t fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
389 if(ricAdmitItems != NULLP)
391 ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
392 ricAdmitItems->criticality = CriticalityE2_reject;
393 ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
394 ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
402 /*******************************************************************
404 * @brief Builds the mandatory RicAdmitted List Params
408 * Function : BuildRicAdmitList
410 * Functionality: Builds the mandatory Ric Admitted List Params
412 * @params[in] RICaction_Admitted_List_t *admitListPtr
413 * @return ROK - success
416 * ****************************************************************/
418 uint8_t BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
425 if(admitListPtr == NULLP)
427 DU_LOG("\nE2AP : Memory allocation for RIC Admit List failed");
432 admitListPtr->list.count = elementCnt;
433 admitListPtr->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
434 DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
435 if(admitListPtr->list.array == NULLP)
437 DU_LOG("\nE2AP : Memory allocation for RIC Admit List failed");
442 for(idx=0 ; idx<elementCnt ; idx++ )
444 DU_ALLOC(admitListPtr->list.array[idx], sizeof(RICaction_Admitted_ItemIEs_t));
445 if(admitListPtr->list.array[idx] == NULLP)
453 fillRicAdmitList((RICaction_Admitted_ItemIEs_t *)admitListPtr->list.array[idx]);
459 /*******************************************************************
461 * @breif Deallocation of BuildAndSendRicSubscriptionRsp memory
465 * Function : FreeRicSubscriptionRsp
467 * Functionality:Free the RicSubscriptionRsp
469 * @param[in] E2AP_PDU_t *e2apRicMsg
474 ******************************************************************/
475 void FreeRicSubscriptionRsp(E2AP_PDU_t *e2apRicMsg)
477 RICsubscriptionResponse_t *ricSubscriptionRsp= NULLP;
480 RICaction_Admitted_List_t *admitListPtr;
482 if(e2apRicMsg != NULLP)
484 if(e2apRicMsg->choice.successfulOutcome != NULLP)
486 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
487 if(ricSubscriptionRsp)
489 if(ricSubscriptionRsp->protocolIEs.list.array != NULLP)
491 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
493 if(ricSubscriptionRsp->protocolIEs.list.array[idx] != NULLP)
495 switch(ricSubscriptionRsp->protocolIEs.list.array[idx]->id)
497 case ProtocolIE_IDE2_id_RICrequestID:
500 case ProtocolIE_IDE2_id_RANfunctionID:
503 case ProtocolIE_IDE2_id_RICactions_Admitted:
505 admitListPtr = &ricSubscriptionRsp->protocolIEs.list.\
506 array[idx]->value.choice.RICaction_Admitted_List;
507 if(admitListPtr->list.array != NULLP)
509 for(idx1=0 ; idx1<admitListPtr->list.count; idx1++ )
511 if(admitListPtr->list.array[idx1] != NULLP)
513 DU_FREE(admitListPtr->list.array[idx1],
514 sizeof(RICaction_Admitted_ItemIEs_t));
517 DU_FREE(admitListPtr->list.array, admitListPtr->list.size);
524 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array[idx], \
525 sizeof(RICsubscriptionResponse_IEs_t));
528 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array, \
529 ricSubscriptionRsp->protocolIEs.list.size);
532 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
534 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
537 /*******************************************************************
539 * @brief Builds and Send the RicSubscriptionRsp
543 * Function : BuildAndSendRicSubscriptionRsp
545 * functionality:Fills the RicSubscriptionRsp
547 * @return ROK - success
550 ******************************************************************/
551 uint8_t FillRicSubscriptionRsp(RICsubscriptionResponse_t *ricSubscriptionRsp )
555 uint8_t elementCnt = 0;
556 uint8_t BuildRicRequestIdret=ROK;
557 uint8_t BuildRicAdmitListret=ROK;
560 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
561 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
562 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
563 ricSubscriptionRsp->protocolIEs.list.size);
564 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
566 DU_LOG("\nE2AP : Memory allocation for FillRicSubscriptionRsp failed");
571 for(idx=0; idx<ricSubscriptionRsp->protocolIEs.list.count; idx++)
573 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
574 sizeof(RICsubscriptionResponse_IEs_t));
575 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
584 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
585 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
586 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
587 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
588 BuildRicRequestIdret =
589 BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
590 if(BuildRicRequestIdret != ROK)
597 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
598 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
599 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
600 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
601 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
604 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
605 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
606 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
607 RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
608 BuildRicAdmitListret =
609 BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
610 if(BuildRicAdmitListret != ROK)
619 /*******************************************************************
621 * @brief Builds and Send the RicSubscriptionRsp
625 * Function : BuildAndSendRicSubscriptionRsp
627 * Functionality:Fills the RicSubscriptionRsp
629 * @return ROK - success
632 ******************************************************************/
634 uint8_t BuildAndSendRicSubscriptionRsp()
637 E2AP_PDU_t *e2apRicMsg = NULLP;
638 RICsubscriptionResponse_t *ricSubscriptionRsp=NULLP;
639 asn_enc_rval_t encRetVal;
640 uint8_t ret = RFAILED;
641 uint8_t FillRicricSubscriptionRspret;
645 DU_LOG("\nE2AP : Building RIC Subscription Response\n");
647 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
648 if(e2apRicMsg == NULLP)
650 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
653 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
654 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
655 if(e2apRicMsg->choice.successfulOutcome == NULLP)
657 DU_LOG("\nE2AP : Memory allocation for Ric subscription Response failed");
661 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
662 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
663 e2apRicMsg->choice.successfulOutcome->value.present = \
664 SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
665 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
667 FillRicricSubscriptionRspret = FillRicSubscriptionRsp(ricSubscriptionRsp);
668 if(FillRicricSubscriptionRspret != ROK)
670 DU_LOG("\nE2AP : Memory allocation for RICsubscriptionResponseIE failed");
674 /* Prints the Msg formed */
675 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
677 cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
679 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
681 if(encRetVal.encoded == ENCODE_FAIL)
683 DU_LOG("\nE2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
684 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
689 DU_LOG("\nE2AP : Created APER encoded buffer for RIC subscription response \n");
690 for(int i=0; i< encBufSize; i++)
692 printf("%x",encBuf[i]);
696 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
698 DU_LOG("\nE2AP : Sending RIC Subscription Response failed");
706 FreeRicSubscriptionRsp(e2apRicMsg);
710 /******************************************************************
712 * @brief Processes E2 Setup Response sent by RIC
716 * Function : procE2SetupRsp
718 * Functionality: Processes E2 Setup Response sent by RIC
720 * @params[in] E2AP_PDU_t ASN decoded E2AP message
721 * @return ROK - success
724 * ****************************************************************/
725 uint8_t procE2SetupRsp(E2AP_PDU_t *e2apMsg)
729 E2setupResponse_t *e2SetRspMsg;
731 DU_LOG("\nE2AP : E2 Setup Response received");
732 duCb.e2Status = TRUE; //Set E2 status as true
733 e2SetRspMsg = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
735 for(idx=0; idx<e2SetRspMsg->protocolIEs.list.count; idx++)
737 switch(e2SetRspMsg->protocolIEs.list.array[idx]->id)
739 case ProtocolIE_IDE2_id_GlobalRIC_ID:
741 /* To store the Ric Id Params */
742 recvBufLen = sizeof(e2SetRspMsg->protocolIEs.list.array[idx]->value\
743 .choice.GlobalRIC_ID.pLMN_Identity.size);
744 e2apMsgDb.plmn = NULLP;
745 DU_ALLOC(e2apMsgDb.plmn, recvBufLen);
748 memcpy(e2apMsgDb.plmn, e2SetRspMsg->protocolIEs.list.array[idx]\
749 ->value.choice.GlobalRIC_ID.pLMN_Identity.buf, recvBufLen);
751 bitStringToInt(&e2SetRspMsg->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID.ric_ID, &e2apMsgDb.ricId);
752 /*TODO : e2apMsgDb.plmn memory to be deallocated after the usage */
756 DU_LOG("\nE2AP : Invalid IE received in E2SetupRsp:%ld",
757 e2SetRspMsg->protocolIEs.list.array[idx]->id);
764 /******************************************************************
766 * @brief Processes RIC Subscription Req sent by RIC
770 * Function : procRicSubsReq
772 * Functionality: Processes E2 Setup Response sent by CU
774 * @params[in] E2AP_PDU_t ASN decoded E2AP message
775 * @return ROK - success
778 * ****************************************************************/
780 uint8_t procRicSubsReq(E2AP_PDU_t *e2apMsg)
786 RICsubscriptionRequest_t *ricSubsReq;
787 RICaction_ToBeSetup_ItemIEs_t *actionItem;
789 DU_LOG("\nE2AP : Ric Subscription request received");
790 ricSubsReq = &e2apMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
792 for(idx=0; idx<ricSubsReq->protocolIEs.list.count; idx++)
794 switch(ricSubsReq->protocolIEs.list.array[idx]->id)
796 case ProtocolIE_IDE2_id_RICrequestID:
798 e2apMsgDb.ricReqId = ricSubsReq->protocolIEs.list.array[idx]->\
799 value.choice.RICrequestID.ricRequestorID;
800 e2apMsgDb.ricInstanceId = ricSubsReq->protocolIEs.list.array[idx]-> \
801 value.choice.RICrequestID.ricInstanceID;
804 case ProtocolIE_IDE2_id_RANfunctionID:
806 e2apMsgDb.ranFuncId = ricSubsReq->protocolIEs.list.array[idx]-> \
807 value.choice.RANfunctionID;
810 case ProtocolIE_IDE2_id_RICsubscriptionDetails:
812 recvBufLen = sizeof(ricSubsReq->protocolIEs.list.array[idx]->value\
813 .choice.RICsubscriptionDetails.ricEventTriggerDefinition.size);
814 e2apMsgDb.ricEventTrigger = NULLP;
815 DU_ALLOC(e2apMsgDb.ricEventTrigger, recvBufLen);
816 /*TODO : e2apMsgDb.ricEventTrigger memory to be deallocated after the usage */
817 if(e2apMsgDb.ricEventTrigger)
819 memcpy(e2apMsgDb.ricEventTrigger, ricSubsReq->protocolIEs.list.array[idx]\
820 ->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf, \
823 actionItem =(RICaction_ToBeSetup_ItemIEs_t *)ricSubsReq->protocolIEs.list\
824 .array[idx]->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List\
827 for(ied = 0; ied < ricSubsReq->protocolIEs.list.array[idx]->value.choice.\
828 RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count; ied++)
830 switch(actionItem->id)
832 case ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item:
834 e2apMsgDb.ricActionId = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionID;
835 e2apMsgDb.ricActionType = actionItem->value.choice.RICaction_ToBeSetup_Item.ricActionType;
839 DU_LOG("\nE2AP : Invalid IE received in RicSetupLst:%ld",actionItem->id);
848 DU_LOG("\nE2AP : Invalid IE received in Ric SubsReq:%ld",
849 ricSubsReq->protocolIEs.list.array[idx]->id);
853 ret = BuildAndSendRicSubscriptionRsp();
858 /*******************************************************************
860 * @brief Free the RicIndication Message
864 * Function : FreeRicIndication
866 * Functionality: Free the RicIndication Message
871 ******************************************************************/
872 void FreeRicIndication(E2AP_PDU_t *e2apMsg)
875 RICindication_t *ricIndicationMsg= NULLP;
880 if(e2apMsg->choice.initiatingMessage != NULLP)
882 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
883 if(ricIndicationMsg!= NULLP)
885 if(ricIndicationMsg->protocolIEs.list.array != NULLP)
887 for(idx=0; idx<ricIndicationMsg->protocolIEs.list.count; idx++)
889 if(ricIndicationMsg->protocolIEs.list.array[idx] != NULLP)
891 switch(ricIndicationMsg->protocolIEs.list.array[idx]->id)
893 case ProtocolIE_IDE2_id_RICrequestID:
896 case ProtocolIE_IDE2_id_RANfunctionID:
899 case ProtocolIE_IDE2_id_RICactionID:
902 case ProtocolIE_IDE2_id_RICindicationType:
905 case ProtocolIE_IDE2_id_RICindicationHeader:
907 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf,\
908 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
911 case ProtocolIE_IDE2_id_RICindicationMessage:
913 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf,\
914 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
920 DU_FREE(ricIndicationMsg->protocolIEs.list.array[idx],sizeof(RICindication_IEs_t));
923 DU_FREE(ricIndicationMsg->protocolIEs.list.array,ricIndicationMsg->protocolIEs.list.size);
926 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
928 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
931 /*******************************************************************
933 * brief Fill the RicIndication Message
937 * Function : FillRicIndication
939 * Functionality:Fills the RicIndication Message
941 * @return ROK - success
944 ******************************************************************/
945 uint8_t FillRicIndication(RICindication_t *ricIndicationMsg)
947 uint8_t elementCnt=0;
952 ricIndicationMsg->protocolIEs.list.count = elementCnt;
953 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t);
954 /* Initialize the Ric Indication members */
955 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
956 ricIndicationMsg->protocolIEs.list.size);
957 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
959 DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
964 for(idx=0; idx<elementCnt; idx++)
966 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
967 sizeof(RICindication_IEs_t));
968 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
970 DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
978 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
979 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
980 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
981 RICindication_IEs__value_PR_RICrequestID;
982 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID =\
984 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID =\
985 e2apMsgDb.ricInstanceId;
988 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
989 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
990 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
991 RICindication_IEs__value_PR_RANfunctionID;
992 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID =
996 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
997 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
998 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
999 RICindication_IEs__value_PR_RICactionID;
1000 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID =
1001 e2apMsgDb.ricActionId;
1004 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
1005 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1006 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1007 RICindication_IEs__value_PR_RICindicationType;
1008 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType =
1009 e2apMsgDb.ricActionType;
1012 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
1013 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1014 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1015 RICindication_IEs__value_PR_RICindicationHeader;
1016 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size = 3 *
1018 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf ,\
1019 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.size);
1020 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader.buf == NULLP)
1022 DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
1027 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1028 &ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader);
1030 /* TO BE CHANGED: RIC INDICATION DATA */
1031 /* For now filling a dummy octect data, need to tested with PRBs*/
1032 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
1033 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
1034 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
1035 RICindication_IEs__value_PR_RICindicationMessage;
1036 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size = 3 *
1038 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf ,\
1039 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.size);
1040 if(ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage.buf == NULLP)
1042 DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
1047 buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
1048 &ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage);
1056 /*******************************************************************
1058 * @brief Builds and Send the RicIndication Message
1062 * Function : BuildAndSendRicIndication
1064 * Functionality:Fills the RicIndication Message
1066 * @return ROK - success
1069 ******************************************************************/
1071 uint8_t BuildAndSendRicIndication()
1073 E2AP_PDU_t *e2apMsg = NULLP;
1074 RICindication_t *ricIndicationMsg=NULLP;
1075 uint8_t elementCnt=0;
1076 asn_enc_rval_t encRetVal; /* Encoder return value */
1077 uint8_t ret = RFAILED;
1078 uint8_t FillRicIndicationret = ROK;
1082 DU_LOG("\nE2AP : Building Ric Indication Message\n");
1084 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1085 if(e2apMsg == NULLP)
1087 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
1091 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1092 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1093 if(e2apMsg->choice.initiatingMessage == NULLP)
1095 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
1098 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
1099 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1100 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
1102 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
1104 FillRicIndicationret = FillRicIndication(ricIndicationMsg);
1105 if(FillRicIndicationret != ROK)
1109 /* Prints the Msg formed */
1110 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1111 cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
1113 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1115 if(encRetVal.encoded == ENCODE_FAIL)
1117 DU_LOG("\nE2AP : Could not encode RIC Indication Message (at %s)\n",\
1118 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1123 DU_LOG("\nE2AP : Created APER encoded buffer for RIC Indication Message \n");
1124 for(int i=0; i< encBufSize; i++)
1126 printf("%x",encBuf[i]);
1130 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1132 DU_LOG("\nE2AP : Sending RIC Indication Message");
1138 FreeRicIndication(e2apMsg);
1142 /*******************************************************************
1144 * @brief Sends E2 msg over SCTP
1148 * Function : SendE2APMsg
1150 * Functionality: Sends E2 msg over SCTP
1152 * @params[in] Region region
1154 * @return ROK - success
1157 * ****************************************************************/
1159 uint8_t SendE2APMsg(Region region, Pool pool)
1163 if(SGetMsg(region, pool, &mBuf) == ROK)
1165 if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
1167 SPrntMsg(mBuf, 0,0);
1169 if(sctpSend(mBuf, E2_INTERFACE) != ROK)
1171 DU_LOG("\nE2AP : SCTP Send for E2 failed");
1178 DU_LOG("\nE2AP : SAddPstMsgMult failed");
1186 DU_LOG("\nE2AP : Failed to allocate memory");
1193 /*******************************************************************
1195 * @brief Handles received E2AP message and sends back response
1199 * Function : E2APMsgHdlr
1202 * - Decodes received E2AP control message
1203 * - Prepares response message, encodes and sends to SCTP
1206 * @return ROK - success
1209 * ****************************************************************/
1210 void E2APMsgHdlr(Buffer *mBuf)
1216 E2AP_PDU_t *e2apMsg;
1217 asn_dec_rval_t rval; /* Decoder return value */
1218 E2AP_PDU_t e2apasnmsg ;
1220 DU_LOG("\nE2AP : Received E2AP message buffer");
1221 SPrntMsg(mBuf, 0,0);
1223 /* Copy mBuf into char array to decode it */
1224 SFndLenMsg(mBuf, &recvBufLen);
1225 if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
1227 DU_LOG("\nE2AP : Memory allocation failed");
1230 if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
1232 DU_LOG("\nE2AP : Failed while copying %d", copyCnt);
1236 printf("\nE2AP : Received flat buffer to be decoded : ");
1237 for(i=0; i< recvBufLen; i++)
1239 printf("%x",recvBuf[i]);
1242 /* Decoding flat buffer into E2AP messsage */
1243 e2apMsg = &e2apasnmsg;
1244 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1246 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1247 SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
1248 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1250 DU_LOG("\nE2AP : ASN decode failed");
1254 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1256 switch(e2apMsg->present)
1258 case E2AP_PDU_PR_successfulOutcome:
1260 switch(e2apMsg->choice.successfulOutcome->value.present)
1262 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
1266 DU_LOG("\nE2AP : Store E2 setup response Params");
1267 procE2SetupRsp(e2apMsg);
1273 DU_LOG("\nE2AP : Invalid type of intiating message [%d]", e2apMsg->choice.initiatingMessage->value.present);
1276 }/* End of switch(successfulOutcome) */
1279 case E2AP_PDU_PR_initiatingMessage:
1281 switch(e2apMsg->choice.initiatingMessage->value.present)
1283 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
1285 DU_LOG("\nE2AP : Calling RIC Subscription Response");
1286 if(procRicSubsReq(e2apMsg) == ROK)
1288 BuildAndSendRicIndication();
1294 DU_LOG("\nE2AP : Invalid type of successfulOutcome message [%d]", e2apMsg->choice.successfulOutcome->value.present);
1297 }/* End of switch(initiatingMessage) */
1302 DU_LOG("\nE2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
1306 }/* End of switch(e2apMsg->present) */
1308 } /* End of E2APMsgHdlr */
1310 /**********************************************************************
1312 **********************************************************************/