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 *******************************************************************************/
19 /* This file contains E2AP message handler functions */
20 #include "common_def.h"
21 #include "OCTET_STRING.h"
22 #include "BIT_STRING.h"
23 #include "odu_common_codec.h"
24 #include "ric_stub_sctp.h"
26 #include "ric_e2ap_msg_hdl.h"
27 #include "GlobalE2node-gNB-ID.h"
28 #include "ProtocolIE-FieldE2.h"
29 #include "InitiatingMessageE2.h"
30 #include "SuccessfulOutcomeE2.h"
31 #include "UnsuccessfulOutcomeE2.h"
34 #include "E2nodeComponentInterfaceF1.h"
37 /*******************************************************************
39 * @brief Sends E2 msg over SCTP
43 * Function : SendE2APMsg
45 * Functionality: Sends E2 msg over SCTP
47 * @params[in] Region region
49 * @return ROK - success
52 * ****************************************************************/
54 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
58 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
60 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
62 ODU_PRINT_MSG(mBuf, 0,0);
64 if(sctpSend(duId, mBuf) != ROK)
66 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
67 ODU_PUT_MSG_BUF(mBuf);
73 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
74 ODU_PUT_MSG_BUF(mBuf);
77 ODU_PUT_MSG_BUF(mBuf);
81 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
88 /*******************************************************************
90 * @brief Builds Global RIC Id Params
94 * Function : BuildGlobalRicId
96 * Functionality: Building the Plmn and ric id
98 * @params[in] GlobalRIC_ID_t *ricId
99 * @return ROK - success
102 * ****************************************************************/
104 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
107 uint8_t byteSize = 3;
111 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
112 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
113 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
115 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
116 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
117 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
122 /*******************************************************************
124 * @brief deallocate the memory allocated in E2SetupResponse
128 * Function : FreeE2SetupRsp
130 * Functionality: deallocate the memory allocated in E2SetupResponse
132 * @params[in] E2AP_PDU_t *e2apMsg
135 * ****************************************************************/
136 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
139 E2setupResponse_t *e2SetupRsp;
143 if(e2apMsg->choice.successfulOutcome)
145 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
146 if(e2SetupRsp->protocolIEs.list.array)
148 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
150 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
152 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
154 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
156 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
160 /*******************************************************************
162 * @brief Build E2node Component config addition ack list
166 * Function : BuildE2nodeComponentConfigAdditionAck
168 * Functionality: deallocate the memory allocated in E2SetupResponse
170 * @params[in] E2nodeComponentConfigAdditionAck_List_t
171 * *e2NodeConfigAdditionAckList
173 * @return ROK - success
175 * ****************************************************************/
176 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, uint8_t duId)
179 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
181 e2NodeConfigAdditionAckList->list.count = 1;
182 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
183 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
184 if(e2NodeConfigAdditionAckList->list.array == NULLP)
186 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
190 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
192 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
193 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
195 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
199 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[0];
200 e2NodeAddAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
201 e2NodeAddAckItem->criticality = CriticalityE2_reject;
202 e2NodeAddAckItem->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
203 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_f1;
205 /* >E2 Node Component ID */
206 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
207 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
208 sizeof(E2nodeComponentInterfaceF1_t));
209 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
211 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
214 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
215 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
216 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
218 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
220 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
223 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duId;
225 /* >E2 Node Component Configuration Acknowledge*/
226 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentConfigurationAck.updateOutcome = \
227 E2nodeComponentConfigurationAck__updateOutcome_success;
231 /*******************************************************************
233 * @brief Builds and sends the E2SetupResponse
237 * Function : BuildAndSendE2SetupRsp
239 * Functionality: Constructs the F1SetupResponse message and sends
240 * it back to the DU through SCTP.
242 * @params[in] void **buf,Buffer to which encoded pattern is written into
243 * @params[in] int *size,size of buffer
245 * @return ROK - success
248 * ****************************************************************/
249 uint8_t BuildAndSendE2SetupRsp(uint32_t duId, uint8_t transId)
251 E2AP_PDU_t *e2apMsg = NULL;
252 E2setupResponse_t *e2SetupRsp;
253 asn_enc_rval_t encRetVal;
256 bool memAllocFailed = false;
258 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
261 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
264 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
267 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
268 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
269 if(e2apMsg->choice.successfulOutcome == NULLP)
271 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
275 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
276 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
277 e2apMsg->choice.successfulOutcome->value.present = \
278 SuccessfulOutcomeE2__value_PR_E2setupResponse;
279 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
282 e2SetupRsp->protocolIEs.list.count = elementCnt;
283 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
285 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
286 if(e2SetupRsp->protocolIEs.list.array == NULLP)
288 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
292 for(idx=0; idx<elementCnt; idx++)
294 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
295 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
297 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
298 memAllocFailed = true;
303 if(memAllocFailed == true)
305 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
310 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
311 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
312 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
313 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
317 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
318 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
319 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
320 E2setupResponseIEs__value_PR_GlobalRIC_ID;
322 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
324 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
328 /* E2 Node Component Configuration Addition Acknowledge List*/
330 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
331 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
332 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
333 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
334 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->value.choice.E2nodeComponentConfigAdditionAck_List, duId)!=ROK)
336 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
340 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
341 memset(encBuf, 0, ENC_BUF_MAX_LEN);
343 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
345 /* Check encode results */
346 if(encRetVal.encoded == ENCODE_FAIL)
348 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
349 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
354 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
355 for(int i=0; i< encBufSize; i++)
357 DU_LOG("%x",encBuf[i]);
361 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
363 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
369 FreeE2SetupRsp(e2apMsg);
370 BuildAndSendRicSubscriptionReq(duId);
374 /*******************************************************************
376 * @brief Builds Ric Request Id
380 * Function : BuildRicRequestId
382 * Functionality: Building the Ric Request Id
384 * @params[in] RICrequestID_t *ricReqId
385 * @return ROK - success
388 * ****************************************************************/
390 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
393 if(ricReqId != NULLP)
395 ricReqId->ricRequestorID = 1;
396 ricReqId->ricInstanceID = 1;
401 /*******************************************************************
403 * @brief Fills Ric Action To be Setup Item
407 * Function : fillSetupItems
409 * Functionality: Filling ricAction Id, RicActionType
411 * @params[in] RICaction_ToBeSetup_Item_t *setupItems
412 * @return pointer of type RICaction_ToBeSetup_Item_t
414 * ****************************************************************/
416 RICaction_ToBeSetup_Item_t* fillSetupItems(RICaction_ToBeSetup_Item_t *setupItems)
418 if(setupItems != NULLP)
420 setupItems->ricActionID = 0;
421 setupItems->ricActionType = RICactionType_report;
427 /*******************************************************************
429 * @brief Fills RIC Subscription Details Item List
433 * Function : fillSubsDetails
435 * Functionality: Fill the RIC Subscription Details Items List
437 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
438 * @return ROK - success
441 * ****************************************************************/
443 uint8_t fillSubsDetails(RICaction_ToBeSetup_ItemIEs_t *items)
447 items->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
448 items->criticality = CriticalityE2_ignore;
449 items->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
450 fillSetupItems(&(items->value.choice.RICaction_ToBeSetup_Item));
455 /*******************************************************************
457 * @brief builds RIC Subscription Details
461 * Function : BuildsRicSubsDetails
463 * Functionality: Builds the RIC Subscription Details
465 * @params[in] RICsubscriptionDetails_t *subsDetails
466 * @return ROK - success
469 * ****************************************************************/
471 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
476 if(subsDetails != NULLP)
478 /* Octet string to be build here */
479 /* Sending PLMN as Octect string */
480 uint8_t byteSize = 3;
481 subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(uint8_t);
482 RIC_ALLOC(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
483 buildPlmnId(ricCb.ricCfgParams.plmn, subsDetails->ricEventTriggerDefinition.buf);
485 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
486 subsDetails->ricAction_ToBeSetup_List.list.size = \
487 elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t);
488 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, \
489 subsDetails->ricAction_ToBeSetup_List.list.size);
490 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
492 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
495 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[0],\
496 sizeof(RICaction_ToBeSetup_ItemIEs_t));
497 fillSubsDetails(subsDetails->ricAction_ToBeSetup_List.list.array[0]);
502 /*******************************************************************
504 * @brief Builds and Send the RicSubscriptionReq
508 * Function : BuildAndSendRicSubscriptionReq
510 * Functionality:Fills the RicSubscriptionReq
512 * @return ROK - success
515 ******************************************************************/
517 uint8_t BuildAndSendRicSubscriptionReq(uint32_t duId)
520 E2AP_PDU_t *e2apRicMsg = NULL;
521 RICsubscriptionRequest_t *ricSubscriptionReq;
526 asn_enc_rval_t encRetVal; /* Encoder return value */
528 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
530 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
531 if(e2apRicMsg == NULLP)
533 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
537 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
538 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
539 if(e2apRicMsg->choice.initiatingMessage == NULLP)
541 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
542 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
545 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
546 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
547 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
549 RIC_ALLOC(ricSubscriptionReq, sizeof(RICsubscriptionRequest_t));
550 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
553 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
554 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
556 /* Initialize the subscription members */
557 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, \
558 ricSubscriptionReq->protocolIEs.list.size);
559 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
561 DU_LOG("\nERROR --> E2AP : Memory allocation for RICSubscriptionRequestIEs failed");
562 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
563 RIC_FREE(e2apRicMsg, (Size)sizeof(E2AP_PDU_t));
567 for(idx=0; idx<elementCnt; idx++)
569 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx],\
570 sizeof(RICsubscriptionRequest_IEs_t));
571 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
573 for(ieId=0; ieId<idx; ieId++)
575 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[ieId],\
576 sizeof(RICsubscriptionRequest_IEs_t));
578 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array,\
579 ricSubscriptionReq->protocolIEs.list.size);
580 RIC_FREE(e2apRicMsg->choice.initiatingMessage, \
581 sizeof(InitiatingMessageE2_t));
582 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
587 /* Filling RIC Request Id */
589 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
590 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
591 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
592 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
594 BuildRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID);
597 /* Filling RAN Function Id */
599 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
600 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
601 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
602 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
603 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
606 /* Filling RIC Subscription Details */
608 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
609 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
610 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
611 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
613 BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
616 /* Prints the Msg formed */
617 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
619 memset(encBuf, 0, ENC_BUF_MAX_LEN);
621 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
623 if(encRetVal.encoded == ENCODE_FAIL)
625 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
626 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
631 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
632 for(int i=0; i< encBufSize; i++)
634 DU_LOG("%x",encBuf[i]);
640 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
642 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
649 /*******************************************************************
651 * @brief Process RicSubscriptionResponse
655 * Function : ProcRicSubscriptionRsp
657 * Functionality: Processes RicSubscriptionRsp
661 ******************************************************************/
663 void ProcRicSubscriptionResponse(uint32_t duId)
668 DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged");
670 SEARCH_DU_DB(duIdx, duId, duDb);
672 duDb->ricSubscribedToDu = true;
675 /*******************************************************************
677 * @brief deallocate the memory allocated in E2SetupFailure
681 * Function : FreeE2SetupFailure
683 * Functionality: deallocate the memory allocated in E2SetupFailure
685 * @params[in] E2AP_PDU_t *e2apMsg
688 * ****************************************************************/
689 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
692 E2setupFailure_t *e2SetupFail;
696 if(e2apMsg->choice.unsuccessfulOutcome)
698 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
699 if(e2SetupFail->protocolIEs.list.array)
701 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
703 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
705 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
707 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
709 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
713 /*******************************************************************
715 * @brief Buld and send the E2 Setup failure
719 * Function : BuildAndSendE2SetupFailure
722 * - Buld and send the E2 Setup failure
723 * @return ROK - success
726 * ****************************************************************/
728 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
730 E2AP_PDU_t *e2apMsg = NULL;
731 E2setupFailure_t *e2SetupFailure;
732 asn_enc_rval_t encRetVal;
735 bool memAllocFailed = false;
737 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
740 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
743 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
746 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
747 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
748 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
750 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
754 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
755 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
756 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
757 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
760 e2SetupFailure->protocolIEs.list.count = elementCnt;
761 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
763 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
764 if(e2SetupFailure->protocolIEs.list.array == NULLP)
766 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
770 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
772 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
773 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
775 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
776 memAllocFailed = true;
781 if(memAllocFailed == true)
783 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
789 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
790 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
791 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
792 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
795 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
796 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
797 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
798 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
799 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
802 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
803 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
804 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
805 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
807 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
808 memset(encBuf, 0, ENC_BUF_MAX_LEN);
810 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
812 /* Check encode results */
813 if(encRetVal.encoded == ENCODE_FAIL)
815 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
816 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
821 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
822 for(int i=0; i< encBufSize; i++)
824 DU_LOG("%x",encBuf[i]);
828 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
830 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
836 FreeE2SetupFailure(e2apMsg);
839 /*******************************************************************
841 * @brief process the e2setup request
845 * Function : ProcE2SetupReq
847 * Functionality: process the e2setup request
849 * @return ROK - success
852 ******************************************************************/
854 uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
856 uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0;
858 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
859 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
863 if(e2SetupReq->protocolIEs.list.array)
865 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
867 if(e2SetupReq->protocolIEs.list.array[arrIdx])
869 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
871 case ProtocolIE_IDE2_id_TransactionID:
873 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
876 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
878 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
879 if(e2NodeAddList->list.array)
881 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
883 if(e2NodeAddList->list.array[e2NodeAddListIdx])
885 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
886 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
887 e2nodeComponentInterfaceTypeF1)
889 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
890 e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf)
892 *duId = e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.\
893 choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
894 SEARCH_DU_DB(duIdx, duId, duDb);
897 duDb = &ricCb.duInfo[ricCb.numDu];
900 memset(duDb, 0, sizeof(DuDb));
903 if(BuildAndSendE2SetupRsp(*duId, transId) !=ROK)
905 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
925 /*******************************************************************
927 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
931 * Function : FreeE2NodeConfigUpdate
934 * - freeing the memory allocated for E2nodeConfigurationUpdate
936 * @params[in] E2AP_PDU_t *e2apMsg
937 * @return ROK - success
940 * ****************************************************************/
941 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
944 E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck;
948 if(e2apMsg->choice.successfulOutcome != NULLP)
950 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
951 if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP)
953 for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
955 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t));
957 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
959 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
961 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
965 /*******************************************************************
967 * @brief Buld and send the E2 node config update msg
971 * Function : BuildAndSendE2NodeConfigUpdate
974 * - Buld and send the E2 node config update msg
975 * @return ROK - success
978 * ****************************************************************/
980 uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId)
982 uint8_t arrIdx = 0,elementCnt = 1;
984 E2AP_PDU_t *e2apMsg = NULLP;
985 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
986 asn_enc_rval_t encRetVal; /* Encoder return value */
988 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
991 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
994 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
997 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
998 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
999 if(e2apMsg->choice.successfulOutcome == NULLP)
1001 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1002 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1006 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1007 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
1008 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
1009 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1011 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
1012 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
1013 /* Initialize the Ric Indication members */
1014 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \
1015 e2NodeConfigUpdateAck->protocolIEs.list.size);
1016 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
1018 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1022 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
1024 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
1025 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
1028 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1035 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1036 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1037 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
1038 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
1041 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1043 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1045 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1047 if(encRetVal.encoded == ENCODE_FAIL)
1049 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
1050 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1055 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
1056 for(int i=0; i< encBufSize; i++)
1058 DU_LOG("%x",encBuf[i]);
1064 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1066 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
1073 FreeE2NodeConfigUpdateAck(e2apMsg);
1077 /*******************************************************************
1079 * @brief Deallocate the memory allocated for E2 Reset Response
1083 * Function : FreeE2ResetResponse
1086 * - freeing the memory allocated for E2ResetResponse
1088 * @params[in] E2AP_PDU_t *e2apMsg
1089 * @return ROK - success
1092 * ****************************************************************/
1093 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
1096 ResetResponseE2_t *resetResponse;
1098 if(e2apMsg != NULLP)
1100 if(e2apMsg->choice.successfulOutcome != NULLP)
1102 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1103 if(resetResponse->protocolIEs.list.array)
1105 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1107 if(resetResponse->protocolIEs.list.array[ieIdx])
1109 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1112 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1114 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1116 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1120 /*******************************************************************
1122 * @brief Buld and send the E2 Reset Response msg
1126 * Function : BuildAndSendE2ResetResponse
1129 * - Buld and send the E2 Reset Response Message
1130 * @return ROK - success
1133 * ****************************************************************/
1134 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
1136 uint8_t ieIdx = 0, elementCnt = 0;
1137 uint8_t ret = RFAILED;
1138 E2AP_PDU_t *e2apMsg = NULLP;
1139 ResetResponseE2_t *resetResponse;
1140 asn_enc_rval_t encRetVal; /* Encoder return value */
1142 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
1145 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1146 if(e2apMsg == NULLP)
1148 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
1151 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1153 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1154 if(e2apMsg->choice.successfulOutcome == NULLP)
1156 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
1157 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1161 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
1162 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1163 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
1164 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1167 resetResponse->protocolIEs.list.count = elementCnt;
1168 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
1169 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1170 if(!resetResponse->protocolIEs.list.array)
1172 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
1176 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
1178 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1179 if(!resetResponse->protocolIEs.list.array[ieIdx])
1181 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
1185 if(ieIdx < elementCnt)
1189 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1190 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
1191 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
1192 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
1194 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1196 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1198 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1199 if(encRetVal.encoded == ENCODE_FAIL)
1201 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
1202 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1207 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
1208 for(int i=0; i< encBufSize; i++)
1210 DU_LOG("%x",encBuf[i]);
1215 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1217 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
1225 FreeE2ResetResponse(e2apMsg);
1229 /*******************************************************************
1231 * @brief process the E2 Reset Request
1235 * Function : ProcE2ResetReq
1237 * Functionality: Process E2 Reset Request
1239 * @return ROK - success
1242 ******************************************************************/
1244 uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq)
1246 uint8_t ieIdx = 0, duIdx = 0;
1247 uint8_t transId = 0, cause = 0;
1252 if(resetReq->protocolIEs.list.array)
1254 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
1256 if(resetReq->protocolIEs.list.array[ieIdx])
1258 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
1260 case ProtocolIE_IDE2_id_TransactionID:
1261 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1263 case ProtocolIE_IDE2_id_CauseE2:
1264 DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present);
1265 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
1267 case CauseE2_PR_NOTHING:
1269 case CauseE2_PR_ricRequest:
1270 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest;
1272 case CauseE2_PR_ricService:
1273 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService;
1275 case CauseE2_PR_e2Node:
1276 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node;
1278 case CauseE2_PR_transport:
1279 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport;
1281 case CauseE2_PR_protocol:
1282 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol;
1284 case CauseE2_PR_misc:
1285 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc;
1288 DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause);
1295 BuildAndSendResetResponse(duId, transId);
1299 /*******************************************************************
1301 * @brief Handles received E2AP message and sends back response
1305 * Function : E2APMsgHdlr
1308 * - Decodes received E2AP control message
1309 * - Prepares response message, encodes and sends to SCTP
1312 * @return ROK - success
1315 * ****************************************************************/
1316 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
1322 E2AP_PDU_t *e2apMsg;
1323 asn_dec_rval_t rval; /* Decoder return value */
1324 E2AP_PDU_t e2apasnmsg ;
1326 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
1327 ODU_PRINT_MSG(mBuf, 0,0);
1329 /* Copy mBuf into char array to decode it */
1330 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
1331 RIC_ALLOC(recvBuf, (Size)recvBufLen);
1333 if(recvBuf == NULLP)
1335 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
1338 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
1340 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
1344 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
1345 for(i=0; i< recvBufLen; i++)
1347 DU_LOG("%x",recvBuf[i]);
1350 /* Decoding flat buffer into E2AP messsage */
1351 e2apMsg = &e2apasnmsg;
1352 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
1354 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
1355 RIC_FREE(recvBuf, (Size)recvBufLen);
1357 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1359 DU_LOG("\nERROR --> E2AP : ASN decode failed");
1363 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1365 switch(e2apMsg->present)
1367 case E2AP_PDU_PR_initiatingMessage:
1369 switch(e2apMsg->choice.initiatingMessage->value.present)
1371 case InitiatingMessageE2__value_PR_E2setupRequest:
1373 DU_LOG("\nINFO --> E2AP : E2 setup request received");
1374 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
1377 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
1379 DU_LOG("\nINFO --> E2AP : E2 node config update received");
1380 BuildAndSendE2NodeConfigUpdateAck(*duId);
1383 case InitiatingMessageE2__value_PR_ResetRequestE2:
1385 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
1386 ProcE2ResetReq(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
1389 case InitiatingMessageE2__value_PR_RICindication:
1391 DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged");
1396 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present);
1399 }/* End of switch(initiatingMessage) */
1402 case E2AP_PDU_PR_successfulOutcome:
1404 switch(e2apMsg->choice.successfulOutcome->value.present)
1406 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
1408 ProcRicSubscriptionResponse(*duId);
1413 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present);
1422 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
1426 }/* End of switch(e2apMsg->present) */
1427 } /* End of E2APMsgHdlr */
1430 /**********************************************************************
1432 **********************************************************************/