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 "du_e2ap_msg_hdl.h"
19 #include "du_mgr_main.h"
21 #include "GlobalE2node-gNB-ID.h"
23 #define ENC_BUF_MAX_LEN 100
26 DuCfgParams duCfgParam;
27 char encBuf[ENC_BUF_MAX_LEN];
30 S16 SendE2APMsg(Region , Pool );
33 /*******************************************************************
35 * @brief Writes the encoded chunks into a buffer
39 * Function : PrepFinalEncBuf
41 * Functionality:Fills the encoded buffer
43 * @params[in] void *buffer,initial encoded data
44 * @params[in] size_t size,size of buffer
45 * @params[in] void *encodedBuf,final buffer
46 * @return ROK - success
49 * ****************************************************************/
50 static int PrepFinalEncBuf(const void *buffer, size_t size, void *encodedBuf)
52 memcpy(encodedBuf + encBufSize, buffer, size);
55 } /* PrepFinalEncBuf */
57 /*******************************************************************
59 * @brief Builds PLMN ID
63 * Function : BuildPlmnId
65 * Functionality: Building the PLMN ID
67 * @params[in] PLMNID plmn
68 * OCTET_STRING_t *plmnid
69 * @return ROK - success
72 * ****************************************************************/
74 S16 BuildPlmnId(PlmnId plmn, OCTET_STRING_t *plmnid)
78 DU_ALLOC(plmnid->buf, plmnid->size * sizeof(U8));
79 if(plmnid->buf == NULLP)
84 plmnid->buf[0] = ((plmn.mcc[1] << 4) | (plmn.mcc[0]));
87 plmnid->buf[1] = ((0xf0) | (plmn.mcc[2]));
88 plmnid->buf[2] = ((plmn.mnc[1] << 4) | (plmn.mnc[0]));
92 plmnid->buf[1] = ((plmn.mnc[0] << 4) | (plmn.mcc[2]));
93 plmnid->buf[2] = ((plmn.mnc[2] << 4) | (plmn.mnc[1]));
98 /*******************************************************************
100 * @brief Builds NodeB Id
104 * Function : BuildNodeBId
106 * Functionality: Building the NodeBId
108 * @params[in] BIT_STRING_t *nbid,
113 * @return ROK - success
116 * ****************************************************************/
118 S16 BuildNodeBId(BIT_STRING_t *nbid, U8 unusedBits, U8 byteSize, U8 val)
121 nbid->size = byteSize;
122 DU_ALLOC(nbid->buf, nbid->size * sizeof(U8));
123 if(nbid->buf == NULLP)
128 for (tmp = 0 ; tmp < ((nbid->size)-1); tmp++)
132 nbid->buf[byteSize-1] = val;
133 nbid->bits_unused = unusedBits;
137 /*******************************************************************
139 * @brief Builds Global gNodeB Params
143 * Function : BuildGlobalgNB
145 * Functionality: Building the Plmn and gNB id
147 * @params[in] GlobalE2node_gNB_ID_t *gNbId
148 * @return ROK - success
151 * ****************************************************************/
153 S16 BuildGlobalgNB(GlobalE2node_gNB_ID_t *gNbId)
160 BuildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
161 &gNbId->global_gNB_ID.plmn_id);
163 gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
164 BuildNodeBId(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, val);
170 RANfunction_ItemIEs_t* BuildRanFuncItems(RANfunction_ItemIEs_t *items)
176 items->id = ProtocolIE_IDE2_id_RANfunctionID;
177 items->criticality = CriticalityE2_ignore;
178 items->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
180 items->value.choice.RANfunction_Item.ranFunctionID = 1;
181 BuildPlmn(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, &items->value.choice.RANfunction_Item.ranFunctionDefinition);
182 items->value.choice.RANfunction_Item.ranFunctionRevision = 4;
187 S16 BuildRANList(RANfunctions_List_t *ranFuncList)
192 RANfunction_ItemIEs_t *funcItems;
195 ranFuncList->list.count = elementCnt;
196 ranFuncList->list.size = elementCnt * sizeof(RANfunction_ItemIEs_t);
197 DU_ALLOC(ranFuncList->list.array, \
198 ranFuncList->list.size);
199 if(ranFuncList->list.array == NULLP)
201 DU_LOG("\nE2AP : Memory allocation for RAN Function List failed");
204 /* Fill RAN function Params */
205 DU_ALLOC(ranFuncList->list.array[0], sizeof(RANfunction_ItemIEs_t));
206 BuildRanFuncItems(ranFuncList->list.array[0]);
212 /*******************************************************************
214 * @brief Builds and Send the E2SetupRequest
218 * Function : BuildAndSendE2SetupReq
220 * Functionality:Fills the E2SetupRequest
222 * @return ROK - success
225 ******************************************************************/
227 S16 BuildAndSendE2SetupReq()
229 E2AP_PDU_t *e2apMsg = NULLP;
230 E2setupRequest_t *e2SetupReq;
235 asn_enc_rval_t encRetVal; /* Encoder return value */
237 DU_LOG("\nE2AP : Building E2 Setup Request\n");
239 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
242 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
246 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
247 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
248 if(e2apMsg->choice.initiatingMessage == NULLP)
250 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
251 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
254 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
255 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_E2setup;
256 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_E2setupRequest;
258 DU_ALLOC(e2SetupReq, sizeof(E2setupRequest_t));
259 e2SetupReq = &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest;
263 e2SetupReq->protocolIEs.list.count = elementCnt;
264 e2SetupReq->protocolIEs.list.size = elementCnt * sizeof(E2setupRequestIEs_t);
266 /* Initialize the E2Setup members */
267 DU_ALLOC(e2SetupReq->protocolIEs.list.array, \
268 e2SetupReq->protocolIEs.list.size);
269 if(e2SetupReq->protocolIEs.list.array == NULLP)
271 DU_LOG("\nE2AP : Memory allocation for E2RequestIEs failed");
272 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
273 DU_FREE(e2apMsg, (Size)sizeof(E2AP_PDU_t));
277 for(idx=0; idx<elementCnt; idx++)
279 DU_ALLOC(e2SetupReq->protocolIEs.list.array[idx],\
280 sizeof(E2setupRequestIEs_t));
281 if(e2SetupReq->protocolIEs.list.array[idx] == NULLP)
283 for(ieId=0; ieId<idx; ieId++)
285 DU_FREE(e2SetupReq->protocolIEs.list.array[ieId],\
286 sizeof(E2setupRequestIEs_t));
288 DU_FREE(e2SetupReq->protocolIEs.list.array,\
289 e2SetupReq->protocolIEs.list.size);
290 DU_FREE(e2apMsg->choice.initiatingMessage, \
291 sizeof(InitiatingMessageE2_t));
292 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
298 /* GlobalE2node_gNB_ID */
299 e2SetupReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalE2node_ID;
300 e2SetupReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
301 e2SetupReq->protocolIEs.list.array[idx]->value.present =\
302 E2setupRequestIEs__value_PR_GlobalE2node_ID;
303 e2SetupReq->protocolIEs.list.array[idx]->value.choice.GlobalE2node_ID.present = \
304 GlobalE2node_ID_PR_gNB;
306 GlobalE2node_gNB_ID_t *gNbId;
307 DU_ALLOC(gNbId, sizeof(GlobalE2node_gNB_ID_t));
308 BuildGlobalgNB(gNbId);
309 e2SetupReq->protocolIEs.list.array[idx]->value.choice.GlobalE2node_ID.choice.gNB = gNbId;
311 /* Prints the Msg formed */
312 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
315 cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
317 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
319 if(encRetVal.encoded == ENCODE_FAIL)
321 DU_LOG("\nE2AP : Could not encode E2SetupRequest structure (at %s)\n",\
322 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
327 DU_LOG("\nE2AP : Created APER encoded buffer for E2SetupRequest\n");
328 for(int i=0; i< encBufSize; i++)
330 printf("%x",encBuf[i]);
334 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
336 DU_LOG("\nE2AP : Sending E2 Setup request failed");
341 }/* End of BuildAndSendE2SetupReq */
343 /*******************************************************************
345 * @brief Builds Ric Request Id
349 * Function : BuildRicRequestId
351 * Functionality: Building the Ric Request Id
353 * @params[in] RICrequestID_t *ricReqId
354 * @return ROK - success
357 * ****************************************************************/
359 S16 BuildRicRequestId(RICrequestID_t *ricReqId)
361 if(ricReqId != NULLP)
363 ricReqId->ricRequestorID = 1;
364 ricReqId->ricInstanceID = 1;
369 /*******************************************************************
371 * @brief Fills the mandatory RicAdmitted List Items
375 * Function : fillRicAdmitList
377 * Functionality: Fills the mandatory Ric Admitted List Items
379 * @params[in] RICaction_Admitted_ItemIEs_t *ricAdmitItems
380 * @return ROK - success
383 * ****************************************************************/
385 S16 fillRicAdmitList(RICaction_Admitted_ItemIEs_t *ricAdmitItems)
388 if(ricAdmitItems != NULLP)
390 ricAdmitItems->id = ProtocolIE_IDE2_id_RICaction_Admitted_Item;
391 ricAdmitItems->criticality = CriticalityE2_reject;
392 ricAdmitItems->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
393 ricAdmitItems->value.choice.RICaction_Admitted_Item.ricActionID = 1;
397 /*******************************************************************
399 * @brief Builds the mandatory RicAdmitted List Params
403 * Function : fillRicAdmitList
405 * Functionality: Builds the mandatory Ric Admitted List Params
407 * @params[in] RICaction_Admitted_List_t *admitListPtr
408 * @return ROK - success
411 * ****************************************************************/
413 S16 BuildRicAdmitList(RICaction_Admitted_List_t *admitListPtr)
418 admitListPtr->list.count = elementCnt;
419 admitListPtr->list.size = elementCnt * sizeof(RICaction_Admitted_ItemIEs_t);
420 DU_ALLOC(admitListPtr->list.array, admitListPtr->list.size);
421 if(admitListPtr->list.array == NULLP)
423 DU_LOG("\nE2AP : Memory allocation for RIC Admit List failed");
426 DU_ALLOC(admitListPtr->list.array[0], sizeof(RICaction_Admitted_ItemIEs_t));
427 fillRicAdmitList(admitListPtr->list.array[0]);
432 /*******************************************************************
434 * @brief Builds and Send the RicSubscriptionRsp
438 * Function : BuildAndSendRicSubscriptionRsp
440 * Functionality:Fills the RicSubscriptionRsp
442 * @return ROK - success
445 ******************************************************************/
447 S16 BuildAndSendRicSubscriptionRsp()
450 E2AP_PDU_t *e2apRicMsg = NULLP;
451 RICsubscriptionResponse_t *ricSubscriptionRsp;
452 asn_enc_rval_t encRetVal;
457 DU_LOG("\nE2AP : Building RIC Subscription Response\n");
459 DU_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
460 if(e2apRicMsg == NULLP)
462 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
465 e2apRicMsg->present = E2AP_PDU_PR_successfulOutcome;
466 DU_ALLOC(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
467 if(e2apRicMsg->choice.successfulOutcome == NULLP)
469 DU_LOG("\nE2AP : Memory allocation for Ric subscription Response failed");
470 DU_FREE(e2apRicMsg, sizeof(RICsubscriptionResponse_t));
474 e2apRicMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICsubscription;
475 e2apRicMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
476 e2apRicMsg->choice.successfulOutcome->value.present = \
477 SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse;
478 ricSubscriptionRsp = &e2apRicMsg->choice.successfulOutcome->value.choice.RICsubscriptionResponse;
481 ricSubscriptionRsp->protocolIEs.list.count = elementCnt;
482 ricSubscriptionRsp->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionResponse_IEs_t);
484 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array, \
485 ricSubscriptionRsp->protocolIEs.list.size);
486 if(ricSubscriptionRsp->protocolIEs.list.array == NULLP)
488 DU_LOG("\nE2AP : Memory allocation for RICsubscriptionResponseIE failed");
489 DU_FREE(e2apRicMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
490 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
494 for(idx=0; idx<elementCnt; idx++)
496 DU_ALLOC(ricSubscriptionRsp->protocolIEs.list.array[idx], \
497 sizeof(RICsubscriptionResponse_IEs_t));
498 if(ricSubscriptionRsp->protocolIEs.list.array[idx] == NULLP)
500 DU_FREE(ricSubscriptionRsp->protocolIEs.list.array,\
501 ricSubscriptionRsp->protocolIEs.list.size);
502 DU_FREE(e2apRicMsg->choice.successfulOutcome, \
503 sizeof(SuccessfulOutcomeE2_t));
504 DU_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
509 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
510 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
511 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
512 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
513 BuildRicRequestId(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICrequestID);
516 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
517 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
518 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
519 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
520 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
523 ricSubscriptionRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactions_Admitted;
524 ricSubscriptionRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
525 ricSubscriptionRsp->protocolIEs.list.array[idx]->value.present =\
526 RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
527 BuildRicAdmitList(&ricSubscriptionRsp->protocolIEs.list.array[idx]->value.choice.RICaction_Admitted_List);
530 /* Prints the Msg formed */
531 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
533 cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
535 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
537 if(encRetVal.encoded == ENCODE_FAIL)
539 DU_LOG("\nE2AP : Could not encode RIC Subscription Response structure (at %s)\n",\
540 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
545 DU_LOG("\nE2AP : Created APER encoded buffer for RIC subscription response \n");
546 for(int i=0; i< encBufSize; i++)
548 printf("%x",encBuf[i]);
552 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
554 DU_LOG("\nE2AP : Sending RIC Subscription Response failed");
561 /*******************************************************************
563 * @brief Builds and Send the RicIndication Message
567 * Function : BuildAndSendRicIndication
569 * Functionality:Fills the RicIndication Message
571 * @return ROK - success
574 ******************************************************************/
576 S16 BuildAndSendRicIndication()
578 E2AP_PDU_t *e2apMsg = NULLP;
579 RICindication_t *ricIndicationMsg;
585 asn_enc_rval_t encRetVal; /* Encoder return value */
587 DU_LOG("\nE2AP : Building Ric Indication Message\n");
589 DU_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
592 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
596 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
597 DU_ALLOC(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
598 if(e2apMsg->choice.initiatingMessage == NULLP)
600 DU_LOG("\nE2AP : Memory allocation for E2AP-PDU failed");
601 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
604 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICindication;
605 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
606 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICindication;
608 DU_ALLOC(ricIndicationMsg, sizeof(RICindication_t));
609 ricIndicationMsg = &e2apMsg->choice.initiatingMessage->value.choice.RICindication;
613 ricIndicationMsg->protocolIEs.list.count = elementCnt;
614 ricIndicationMsg->protocolIEs.list.size = elementCnt * sizeof(RICindication_t);
616 /* Initialize the Ric Indication members */
617 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array, \
618 ricIndicationMsg->protocolIEs.list.size);
619 if(ricIndicationMsg->protocolIEs.list.array == NULLP)
621 DU_LOG("\nE2AP : Memory allocation for RICindicationIEs failed");
622 DU_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
623 DU_FREE(e2apMsg, (Size)sizeof(E2AP_PDU_t));
627 for(idx=0; idx<elementCnt; idx++)
629 DU_ALLOC(ricIndicationMsg->protocolIEs.list.array[idx],\
630 sizeof(RICindication_IEs_t));
631 if(ricIndicationMsg->protocolIEs.list.array[idx] == NULLP)
633 for(ieId=0; ieId<idx; ieId++)
635 DU_FREE(ricIndicationMsg->protocolIEs.list.array[ieId],\
636 sizeof(RICindication_IEs_t));
638 DU_FREE(ricIndicationMsg->protocolIEs.list.array,\
639 ricIndicationMsg->protocolIEs.list.size);
640 DU_FREE(e2apMsg->choice.initiatingMessage, \
641 sizeof(InitiatingMessageE2_t));
642 DU_FREE(e2apMsg, sizeof(E2AP_PDU_t));
647 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
648 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
649 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
650 RICindication_IEs__value_PR_RICrequestID;
651 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricRequestorID = e2apMsgDb.ricReqId;
652 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICrequestID.ricInstanceID = e2apMsgDb.ricInstanceId;
655 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
656 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
657 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
658 RICindication_IEs__value_PR_RANfunctionID;
659 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RANfunctionID = e2apMsgDb.ranFuncId;
662 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICactionID;
663 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
664 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
665 RICindication_IEs__value_PR_RICactionID;
666 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICactionID = e2apMsgDb.ricActionId;
670 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationType;
671 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
672 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
673 RICindication_IEs__value_PR_RICindicationType;
675 ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationType = e2apMsgDb.ricActionType;
679 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationHeader;
680 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
681 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
682 RICindication_IEs__value_PR_RICindicationHeader;
683 BuildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
684 &ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationHeader);
686 /* TO BE CHANGED: RIC INDICATION DATA */
687 /* Foe now filling a dummy octect data, need to tested with PRBs*/
689 ricIndicationMsg->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICindicationMessage;
690 ricIndicationMsg->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
691 ricIndicationMsg->protocolIEs.list.array[idx]->value.present = \
692 RICindication_IEs__value_PR_RICindicationMessage;
693 BuildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
694 &ricIndicationMsg->protocolIEs.list.array[idx]->value.choice.RICindicationMessage);
696 /* Prints the Msg formed */
697 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
699 cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
701 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
703 if(encRetVal.encoded == ENCODE_FAIL)
705 DU_LOG("\nE2AP : Could not encode RIC Indication Message (at %s)\n",\
706 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
711 DU_LOG("\nE2AP : Created APER encoded buffer for RIC Indication Message \n");
712 for(int i=0; i< encBufSize; i++)
714 printf("%x",encBuf[i]);
718 if(SendE2APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
720 DU_LOG("\nE2AP : Sending RIC Indication Message");
726 /*******************************************************************
728 * @brief Sends E2 msg over SCTP
732 * Function : SendE2APMsg
734 * Functionality: Sends E2 msg over SCTP
736 * @params[in] Region region
738 * @return ROK - success
741 * ****************************************************************/
743 S16 SendE2APMsg(Region region, Pool pool)
747 if(SGetMsg(region, pool, &mBuf) == ROK)
749 if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
753 if(sctpSend(mBuf, duCfgParam.sctpParams.itfType.e2Itf) != ROK)
755 DU_LOG("\nE2AP : SCTP Send for E2 failed");
762 DU_LOG("\nF1AP : SAddPstMsgMult failed");
770 DU_LOG("\nF1AP : Failed to allocate memory");
777 /*******************************************************************
779 * @brief Handles received E2AP message and sends back response
783 * Function : E2APMsgHdlr
786 * - Decodes received E2AP control message
787 * - Prepares response message, encodes and sends to SCTP
790 * @return ROK - success
793 * ****************************************************************/
794 void E2APMsgHdlr(Buffer *mBuf)
801 asn_dec_rval_t rval; /* Decoder return value */
802 E2AP_PDU_t e2apasnmsg ;
804 DU_LOG("\nE2AP : Received E2AP message buffer");
807 /* Copy mBuf into char array to decode it */
808 SFndLenMsg(mBuf, &recvBufLen);
809 if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
811 DU_LOG("\nE2AP : Memory allocation failed");
814 if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
816 DU_LOG("\nE2AP : Failed while copying %d", copyCnt);
820 printf("\nE2AP : Received flat buffer to be decoded : ");
821 for(i=0; i< recvBufLen; i++)
823 printf("%x",recvBuf[i]);
826 /* Decoding flat buffer into E2AP messsage */
827 e2apMsg = &e2apasnmsg;
828 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
830 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
831 SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
832 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
834 DU_LOG("\nE2AP : ASN decode failed");
838 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
840 switch(e2apMsg->present)
842 case E2AP_PDU_PR_successfulOutcome:
844 switch(e2apMsg->choice.successfulOutcome->value.present)
846 case SuccessfulOutcomeE2__value_PR_E2setupResponse:
850 DU_LOG("\nE2AP : Store E2 setup response Params");
851 procE2SetupRsp(e2apMsg);
857 DU_LOG("\nE2AP : Invalid type of intiating message [%d]", e2apMsg->choice.initiatingMessage->value.present);
860 }/* End of switch(successfulOutcome) */
863 case E2AP_PDU_PR_initiatingMessage:
865 switch(e2apMsg->choice.initiatingMessage->value.present)
867 case InitiatingMessageE2__value_PR_RICsubscriptionRequest:
869 DU_LOG("\nE2AP : Calling RIC Subscription Response");
870 if(procRicSubsReq(e2apMsg) == ROK)
872 BuildAndSendRicIndication();
878 DU_LOG("\nE2AP : Invalid type of successfulOutcome message [%d]", e2apMsg->choice.successfulOutcome->value.present);
881 }/* End of switch(initiatingMessage) */
886 DU_LOG("\nE2AP : Invalid type of e2apMsg->present [%d]",e2apMsg->present);
890 }/* End of switch(e2apMsg->present) */
892 } /* End of E2APMsgHdlr */