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"
35 #include "E2SM-KPM-RANfunction-Description.h"
36 #include "RANfunction-Name.h"
37 #include "RIC-EventTriggerStyle-Item.h"
38 #include "RIC-ReportStyle-Item.h"
39 #include "MeasurementInfo-Action-Item.h"
41 /*******************************************************************
43 * @brief Assigns new transaction id to RIC initiated procedure
47 * Function : assignTransactionId
49 * Functionality: Assigns new transaction id to a RIC initiated
52 * @params[in] Region region
54 * @return ROK - success
57 * ****************************************************************/
59 uint8_t assignTransactionId(DuDb *duDb)
61 uint8_t currTransId = duDb->ricTransIdCounter;
63 /* Update to next valid value */
64 duDb->ricTransIdCounter++;
65 if(duDb->ricTransIdCounter == MAX_NUM_TRANSACTION)
66 duDb->ricTransIdCounter = 0;
71 /*******************************************************************
73 * @brief Sends E2 msg over SCTP
77 * Function : SendE2APMsg
79 * Functionality: Sends E2 msg over SCTP
81 * @params[in] Region region
83 * @return ROK - success
86 * ****************************************************************/
88 uint8_t SendE2APMsg(Region region, Pool pool, uint32_t duId)
92 if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
94 if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
96 ODU_PRINT_MSG(mBuf, 0,0);
98 if(sctpSend(duId, mBuf) != ROK)
100 DU_LOG("\nERROR --> E2AP : SCTP Send for E2 failed");
101 ODU_PUT_MSG_BUF(mBuf);
107 DU_LOG("\nERROR --> E2AP : ODU_ADD_POST_MSG_MULT failed");
108 ODU_PUT_MSG_BUF(mBuf);
111 ODU_PUT_MSG_BUF(mBuf);
115 DU_LOG("\nERROR --> E2AP : Failed to allocate memory");
122 /*******************************************************************
124 * @brief Builds Global RIC Id Params
128 * Function : BuildGlobalRicId
130 * Functionality: Building the Plmn and ric id
132 * @params[in] GlobalRIC_ID_t *ricId
133 * @return ROK - success
136 * ****************************************************************/
138 uint8_t BuildGlobalRicId(GlobalRIC_ID_t *ricId)
141 uint8_t byteSize = 3;
145 ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
146 RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
147 buildPlmnId(ricCb.ricCfgParams.plmn , ricId->pLMN_Identity.buf);
149 ricId->ric_ID.size = byteSize * sizeof(uint8_t);
150 RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
151 fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
156 /*******************************************************************
158 * @brief deallocate the memory allocated in E2SetupResponse
162 * Function : FreeE2SetupRsp
164 * Functionality: deallocate the memory allocated in E2SetupResponse
166 * @params[in] E2AP_PDU_t *e2apMsg
169 * ****************************************************************/
170 void FreeE2SetupRsp(E2AP_PDU_t *e2apMsg)
172 uint8_t arrIdx = 0, e2NodeConfigIdx=0, ranFuncIdx=0;
173 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
174 E2setupResponse_t *e2SetupRsp=NULL;
175 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItemIe=NULL;
176 E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList=NULL;
177 E2nodeComponentInterfaceF1_t *f1InterfaceInfo=NULL;
181 if(e2apMsg->choice.successfulOutcome)
183 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
184 if(e2SetupRsp->protocolIEs.list.array)
186 for(arrIdx=0; arrIdx<e2SetupRsp->protocolIEs.list.count; arrIdx++)
188 switch(e2SetupRsp->protocolIEs.list.array[arrIdx]->id)
190 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
192 ranFuncAcceptedList= &e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
193 if(ranFuncAcceptedList->list.array)
195 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
197 if(ranFuncAcceptedList->list.array[ranFuncIdx])
199 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
202 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
206 case ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck:
208 e2NodeConfigAdditionAckList =&e2SetupRsp->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAdditionAck_List;
209 if(e2NodeConfigAdditionAckList->list.count)
211 for(e2NodeConfigIdx=0; e2NodeConfigIdx<e2NodeConfigAdditionAckList->list.count; e2NodeConfigIdx++)
213 e2NodeAddAckItemIe = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[e2NodeConfigIdx];
214 if(e2NodeAddAckItemIe)
216 f1InterfaceInfo = e2NodeAddAckItemIe->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1;
219 RIC_FREE(f1InterfaceInfo->gNB_DU_ID.buf, f1InterfaceInfo->gNB_DU_ID.size);
220 RIC_FREE(f1InterfaceInfo, sizeof(E2nodeComponentInterfaceF1_t));
222 RIC_FREE(e2NodeAddAckItemIe, sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
225 RIC_FREE(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
230 RIC_FREE(e2SetupRsp->protocolIEs.list.array[arrIdx], sizeof(E2setupResponseIEs_t));
232 RIC_FREE(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
234 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
236 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
240 /*******************************************************************
242 * @brief Build E2node Component config addition ack list
246 * Function : BuildE2nodeComponentConfigAdditionAck
248 * Functionality: deallocate the memory allocated in E2SetupResponse
250 * @params[in] E2nodeComponentConfigAdditionAck_List_t
251 * *e2NodeConfigAdditionAckList
253 * @return ROK - success
255 * ****************************************************************/
257 uint8_t BuildE2nodeComponentConfigAdditionAck(E2nodeComponentConfigAdditionAck_List_t *e2NodeConfigAdditionAckList, DuDb *duDb)
260 E2nodeComponentConfigAdditionAck_ItemIEs_t *e2NodeAddAckItem;
262 e2NodeConfigAdditionAckList->list.count = 1;
263 e2NodeConfigAdditionAckList->list.size = e2NodeConfigAdditionAckList->list.count * sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t*);
264 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array, e2NodeConfigAdditionAckList->list.size);
265 if(e2NodeConfigAdditionAckList->list.array == NULLP)
267 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
271 for(arrIdx = 0; arrIdx< e2NodeConfigAdditionAckList->list.count; arrIdx++)
273 RIC_ALLOC(e2NodeConfigAdditionAckList->list.array[arrIdx], sizeof(E2nodeComponentConfigAdditionAck_ItemIEs_t));
274 if(e2NodeConfigAdditionAckList->list.array[arrIdx] == NULLP)
276 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
280 e2NodeAddAckItem = (E2nodeComponentConfigAdditionAck_ItemIEs_t*) e2NodeConfigAdditionAckList->list.array[0];
281 e2NodeAddAckItem->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck_Item;
282 e2NodeAddAckItem->criticality = CriticalityE2_reject;
283 e2NodeAddAckItem->value.present = E2nodeComponentConfigAdditionAck_ItemIEs__value_PR_E2nodeComponentConfigAdditionAck_Item;
284 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentInterfaceType = duDb->e2NodeComponent.interfaceType;
286 /* >E2 Node Component ID */
287 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeF1;
288 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1,\
289 sizeof(E2nodeComponentInterfaceF1_t));
290 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1 == NULLP)
292 DU_LOG("\nERROR --> E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
295 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size = sizeof(uint8_t);
296 RIC_ALLOC(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf,\
297 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.size);
299 if(e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf == NULLP)
301 DU_LOG("\nERROR -->list. E2AP: Memory allocation failed for BuildE2nodeComponentConfigAdditionAck %d",__LINE__);
304 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0] = duDb->e2NodeComponent.componentId;
306 /* >E2 Node Component Configuration Acknowledge*/
307 e2NodeAddAckItem->value.choice.E2nodeComponentConfigAdditionAck_Item.e2nodeComponentConfigurationAck.updateOutcome = \
308 E2nodeComponentConfigurationAck__updateOutcome_success;
313 /*******************************************************************
315 * @brief Build RAN function accepted list
319 * Function : BuildRanFunctionAcceptedList
321 * Functionality: Build RAN function accepted list
322 * ->For ProcedureCodeE2_id_E2setup or ProcedureCodeE2_id_RICserviceQuery
323 * we add all the RAN Function list which is present in RIC database.
324 * ->For any other procedures, we just fill the RAN functions whose ID
325 * is present in the recvList
329 * Count of ran functions to be accepted in the list
330 * Received list of RAN functions
334 * @return ROK - success
336 * ****************************************************************/
338 uint8_t BuildRanFunctionAcceptedList(DuDb *duDb, uint8_t count, RanFunction *ranFunAcceptedList, RANfunctionsID_List_t *ranFuncAcceptedList, uint8_t procedureCode)
340 uint8_t ranFuncIdx = 0;
341 RANfunctionID_ItemIEs_t *ranFuncAcceptedItemIe=NULL;
343 /* For ProcedureCodeE2_id_E2setup and ProcedureCodeE2_id_RICserviceQuery,
344 * the number of RAN function list items is equal to the number of
345 * ran function entries stored in the database.
346 * For any other procedure, the RAN function list count is equal
347 * to the count of ran functions obtained from the function's caller */
349 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
350 ranFuncAcceptedList->list.count = duDb->numOfRanFunction;
352 ranFuncAcceptedList->list.count = count;
354 ranFuncAcceptedList->list.size = ranFuncAcceptedList->list.count*sizeof(RANfunctionID_ItemIEs_t*);
355 RIC_ALLOC(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
356 if(ranFuncAcceptedList->list.array)
358 for(ranFuncIdx = 0; ranFuncIdx< ranFuncAcceptedList->list.count; ranFuncIdx++)
360 RIC_ALLOC(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
361 if(ranFuncAcceptedList->list.array[ranFuncIdx] == NULLP)
363 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array item");
366 ranFuncAcceptedItemIe = (RANfunctionID_ItemIEs_t*)ranFuncAcceptedList->list.array[ranFuncIdx];
367 ranFuncAcceptedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
368 ranFuncAcceptedItemIe->criticality= CriticalityE2_ignore;
369 ranFuncAcceptedItemIe->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
370 if((procedureCode == ProcedureCodeE2_id_RICserviceQuery)||(procedureCode == ProcedureCodeE2_id_E2setup))
372 /* filling the RAN function information with the help of DuDb */
373 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = duDb->ranFunction[ranFuncIdx].id;
374 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= duDb->ranFunction[ranFuncIdx].revisionCounter;
378 /* filling the the RAN function information with the help received list of RAN functions */
379 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionID = ranFunAcceptedList[ranFuncIdx].id;
380 ranFuncAcceptedItemIe->value.choice.RANfunctionID_Item.ranFunctionRevision= ranFunAcceptedList[ranFuncIdx].revisionCounter;
386 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function added list array");
392 /*******************************************************************
394 * @brief Builds and sends the E2SetupResponse
398 * Function : BuildAndSendE2SetupRsp
400 * Functionality: Constructs the F1SetupResponse message and sends
401 * it back to the DU through SCTP.
403 * @params[in] void **buf,Buffer to which encoded pattern is written into
404 * @params[in] int *size,size of buffer
406 * @return ROK - success
409 * ****************************************************************/
411 uint8_t BuildAndSendE2SetupRsp(DuDb *duDb, uint8_t transId)
413 E2AP_PDU_t *e2apMsg = NULL;
414 E2setupResponse_t *e2SetupRsp;
415 asn_enc_rval_t encRetVal;
418 bool memAllocFailed = false;
420 DU_LOG("\nINFO --> E2AP : Building E2 Setup Response\n");
423 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
426 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
429 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
430 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
431 if(e2apMsg->choice.successfulOutcome == NULLP)
433 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
437 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
438 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
439 e2apMsg->choice.successfulOutcome->value.present = \
440 SuccessfulOutcomeE2__value_PR_E2setupResponse;
441 e2SetupRsp = &e2apMsg->choice.successfulOutcome->value.choice.E2setupResponse;
444 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
445 if(duDb->numOfRanFunction)
448 e2SetupRsp->protocolIEs.list.count = elementCnt;
449 e2SetupRsp->protocolIEs.list.size = elementCnt * sizeof(E2setupResponseIEs_t*);
451 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array, e2SetupRsp->protocolIEs.list.size);
452 if(e2SetupRsp->protocolIEs.list.array == NULLP)
454 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
458 for(idx=0; idx<elementCnt; idx++)
460 RIC_ALLOC(e2SetupRsp->protocolIEs.list.array[idx], sizeof(E2setupResponseIEs_t));
461 if(e2SetupRsp->protocolIEs.list.array[idx] == NULLP)
463 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
464 memAllocFailed = true;
469 if(memAllocFailed == true)
471 DU_LOG("\nERROR --> E2AP : Memory allocation for E2ResponseIEs failed");
476 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_TransactionID;
477 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
478 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_TransactionID;
479 e2SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID = transId;
483 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_GlobalRIC_ID;
484 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
485 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
486 E2setupResponseIEs__value_PR_GlobalRIC_ID;
488 if(BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID))!=ROK)
490 DU_LOG("\nERROR --> E2AP : Failed to build Global Ric Id");
494 if(duDb->numOfRanFunction)
496 /* Accepted RAN function Id */
498 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
499 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
500 e2SetupRsp->protocolIEs.list.array[idx]->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
501 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &e2SetupRsp->protocolIEs.list.array[idx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_E2setup)!=ROK)
503 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
508 /* E2 Node Component Configuration Addition Acknowledge List*/
510 e2SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_E2nodeComponentConfigAdditionAck;
511 e2SetupRsp->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
512 e2SetupRsp->protocolIEs.list.array[idx]->value.present = \
513 E2setupResponseIEs__value_PR_E2nodeComponentConfigAdditionAck_List;
514 if(BuildE2nodeComponentConfigAdditionAck(&e2SetupRsp->protocolIEs.list.array[idx]->value.choice.E2nodeComponentConfigAdditionAck_List, duDb)!=ROK)
516 DU_LOG("\nERROR --> E2AP : Failed to build E2Node Component config addition ack list");
520 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
521 memset(encBuf, 0, ENC_BUF_MAX_LEN);
523 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
525 /* Check encode results */
526 if(encRetVal.encoded == ENCODE_FAIL)
528 DU_LOG("\nERROR --> E2AP : Could not encode E2SetupResponse structure (at %s)\n",\
529 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
534 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2SetupResponse\n");
535 for(int i=0; i< encBufSize; i++)
537 DU_LOG("%x",encBuf[i]);
541 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
543 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Response failed");
549 FreeE2SetupRsp(e2apMsg);
550 BuildAndSendRicSubscriptionReq(duDb->duId);
554 /*******************************************************************
556 * @brief Builds Ric Request Id
560 * Function : BuildRicRequestId
562 * Functionality: Building the Ric Request Id
564 * @params[in] RICrequestID_t *ricReqId
565 * @return ROK - success
568 * ****************************************************************/
570 uint8_t BuildRicRequestId(RICrequestID_t *ricReqId)
573 if(ricReqId != NULLP)
575 ricReqId->ricRequestorID = 1;
576 ricReqId->ricInstanceID = 1;
581 /*******************************************************************
583 * @brief Fills Ric Action To be Setup Item
587 * Function : fillSetupItems
589 * Functionality: Filling ricAction Id, RicActionType
591 * @params[in] RICaction_ToBeSetup_Item_t *setupItems
592 * @return pointer of type RICaction_ToBeSetup_Item_t
594 * ****************************************************************/
596 RICaction_ToBeSetup_Item_t* fillSetupItems(RICaction_ToBeSetup_Item_t *setupItems)
598 if(setupItems != NULLP)
600 setupItems->ricActionID = 0;
601 setupItems->ricActionType = RICactionType_report;
607 /*******************************************************************
609 * @brief Fills RIC Subscription Details Item List
613 * Function : fillSubsDetails
615 * Functionality: Fill the RIC Subscription Details Items List
617 * @params[in] RICaction_ToBeSetup_ItemIEs_t *items
618 * @return ROK - success
621 * ****************************************************************/
623 uint8_t fillSubsDetails(RICaction_ToBeSetup_ItemIEs_t *items)
627 items->id = ProtocolIE_IDE2_id_RICaction_ToBeSetup_Item;
628 items->criticality = CriticalityE2_ignore;
629 items->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
630 fillSetupItems(&(items->value.choice.RICaction_ToBeSetup_Item));
635 /*******************************************************************
637 * @brief builds RIC Subscription Details
641 * Function : BuildsRicSubsDetails
643 * Functionality: Builds the RIC Subscription Details
645 * @params[in] RICsubscriptionDetails_t *subsDetails
646 * @return ROK - success
649 * ****************************************************************/
651 uint8_t BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
656 if(subsDetails != NULLP)
658 /* Octet string to be build here */
659 /* Sending PLMN as Octect string */
660 uint8_t byteSize = 3;
661 subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(uint8_t);
662 RIC_ALLOC(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
663 buildPlmnId(ricCb.ricCfgParams.plmn, subsDetails->ricEventTriggerDefinition.buf);
665 subsDetails->ricAction_ToBeSetup_List.list.count = elementCnt;
666 subsDetails->ricAction_ToBeSetup_List.list.size = \
667 elementCnt * sizeof(RICaction_ToBeSetup_ItemIEs_t);
668 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array, \
669 subsDetails->ricAction_ToBeSetup_List.list.size);
670 if(subsDetails->ricAction_ToBeSetup_List.list.array == NULLP)
672 DU_LOG("\nERROR --> E2AP : Memory allocation for RICactionToBeSetup Items failed");
675 RIC_ALLOC(subsDetails->ricAction_ToBeSetup_List.list.array[0],\
676 sizeof(RICaction_ToBeSetup_ItemIEs_t));
677 fillSubsDetails(subsDetails->ricAction_ToBeSetup_List.list.array[0]);
682 /*******************************************************************
684 * @brief Builds and Send the RicSubscriptionReq
688 * Function : BuildAndSendRicSubscriptionReq
690 * Functionality:Fills the RicSubscriptionReq
692 * @return ROK - success
695 ******************************************************************/
697 uint8_t BuildAndSendRicSubscriptionReq(uint32_t duId)
700 E2AP_PDU_t *e2apRicMsg = NULL;
701 RICsubscriptionRequest_t *ricSubscriptionReq;
706 asn_enc_rval_t encRetVal; /* Encoder return value */
708 DU_LOG("\nINFO --> E2AP : Building RIC Subscription Request\n");
710 RIC_ALLOC(e2apRicMsg, sizeof(E2AP_PDU_t));
711 if(e2apRicMsg == NULLP)
713 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
717 e2apRicMsg->present = E2AP_PDU_PR_initiatingMessage;
718 RIC_ALLOC(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
719 if(e2apRicMsg->choice.initiatingMessage == NULLP)
721 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
722 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
725 e2apRicMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICsubscription;
726 e2apRicMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
727 e2apRicMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICsubscriptionRequest;
729 RIC_ALLOC(ricSubscriptionReq, sizeof(RICsubscriptionRequest_t));
730 ricSubscriptionReq = &e2apRicMsg->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
733 ricSubscriptionReq->protocolIEs.list.count = elementCnt;
734 ricSubscriptionReq->protocolIEs.list.size = elementCnt * sizeof(RICsubscriptionRequest_IEs_t);
736 /* Initialize the subscription members */
737 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array, \
738 ricSubscriptionReq->protocolIEs.list.size);
739 if(ricSubscriptionReq->protocolIEs.list.array == NULLP)
741 DU_LOG("\nERROR --> E2AP : Memory allocation for RICSubscriptionRequestIEs failed");
742 RIC_FREE(e2apRicMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
743 RIC_FREE(e2apRicMsg, (Size)sizeof(E2AP_PDU_t));
747 for(idx=0; idx<elementCnt; idx++)
749 RIC_ALLOC(ricSubscriptionReq->protocolIEs.list.array[idx],\
750 sizeof(RICsubscriptionRequest_IEs_t));
751 if(ricSubscriptionReq->protocolIEs.list.array[idx] == NULLP)
753 for(ieId=0; ieId<idx; ieId++)
755 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array[ieId],\
756 sizeof(RICsubscriptionRequest_IEs_t));
758 RIC_FREE(ricSubscriptionReq->protocolIEs.list.array,\
759 ricSubscriptionReq->protocolIEs.list.size);
760 RIC_FREE(e2apRicMsg->choice.initiatingMessage, \
761 sizeof(InitiatingMessageE2_t));
762 RIC_FREE(e2apRicMsg, sizeof(E2AP_PDU_t));
767 /* Filling RIC Request Id */
769 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICrequestID;
770 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
771 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
772 RICsubscriptionRequest_IEs__value_PR_RICrequestID;
774 BuildRicRequestId(&ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICrequestID);
777 /* Filling RAN Function Id */
779 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RANfunctionID;
780 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
781 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
782 RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
783 ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RANfunctionID = 1;
786 /* Filling RIC Subscription Details */
788 ricSubscriptionReq->protocolIEs.list.array[idx]->id = ProtocolIE_IDE2_id_RICsubscriptionDetails;
789 ricSubscriptionReq->protocolIEs.list.array[idx]->criticality = CriticalityE2_reject;
790 ricSubscriptionReq->protocolIEs.list.array[idx]->value.present =\
791 RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
793 BuildRicSubsDetails(&(ricSubscriptionReq->protocolIEs.list.array[idx]->value.choice.RICsubscriptionDetails));
796 /* Prints the Msg formed */
797 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
799 memset(encBuf, 0, ENC_BUF_MAX_LEN);
801 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
803 if(encRetVal.encoded == ENCODE_FAIL)
805 DU_LOG("\nERROR --> E2AP : Could not encode RicSubscriptionRequest structure (at %s)\n",\
806 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
811 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RicSubscriptionRequest\n");
812 for(int i=0; i< encBufSize; i++)
814 DU_LOG("%x",encBuf[i]);
820 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
822 DU_LOG("\nERROR --> E2AP : Sending RIC subscription Request failed");
829 /*******************************************************************
831 * @brief Process RicSubscriptionResponse
835 * Function : ProcRicSubscriptionRsp
837 * Functionality: Processes RicSubscriptionRsp
841 ******************************************************************/
843 void ProcRicSubscriptionResponse(uint32_t duId)
848 DU_LOG("\nINFO --> E2AP : RICsubscriptionResponse Msg Acknowledged");
850 SEARCH_DU_DB(duIdx, duId, duDb);
852 duDb->ricSubscribedToDu = true;
855 /*******************************************************************
857 * @brief deallocate the memory allocated in E2SetupFailure
861 * Function : FreeE2SetupFailure
863 * Functionality: deallocate the memory allocated in E2SetupFailure
865 * @params[in] E2AP_PDU_t *e2apMsg
868 * ****************************************************************/
869 void FreeE2SetupFailure(E2AP_PDU_t *e2apMsg)
872 E2setupFailure_t *e2SetupFail;
876 if(e2apMsg->choice.unsuccessfulOutcome)
878 e2SetupFail = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
879 if(e2SetupFail->protocolIEs.list.array)
881 for(arrIdx=0; arrIdx<e2SetupFail->protocolIEs.list.count; arrIdx++)
883 RIC_FREE(e2SetupFail->protocolIEs.list.array[arrIdx], sizeof(E2setupFailureIEs_t));
885 RIC_FREE(e2SetupFail->protocolIEs.list.array, e2SetupFail->protocolIEs.list.size);
887 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
889 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
893 /*******************************************************************
895 * @brief Buld and send the E2 Setup failure
899 * Function : BuildAndSendE2SetupFailure
902 * - Buld and send the E2 Setup failure
903 * @return ROK - success
906 * ****************************************************************/
908 uint8_t BuildAndSendE2SetupFailure(uint32_t duId, uint8_t transId)
910 E2AP_PDU_t *e2apMsg = NULL;
911 E2setupFailure_t *e2SetupFailure;
912 asn_enc_rval_t encRetVal;
915 bool memAllocFailed = false;
917 DU_LOG("\nINFO --> E2AP : Building E2 Setup failure\n");
920 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
923 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
926 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
927 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
928 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
930 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
934 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_E2setup;
935 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
936 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_E2setupFailure;
937 e2SetupFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.E2setupFailure;
940 e2SetupFailure->protocolIEs.list.count = elementCnt;
941 e2SetupFailure->protocolIEs.list.size = elementCnt * sizeof(struct E2setupFailureIEs *);
943 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array, e2SetupFailure->protocolIEs.list.size);
944 if(e2SetupFailure->protocolIEs.list.array == NULLP)
946 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
950 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
952 RIC_ALLOC(e2SetupFailure->protocolIEs.list.array[arrIdx], sizeof(struct E2setupFailureIEs));
953 if(e2SetupFailure->protocolIEs.list.array[arrIdx] == NULLP)
955 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
956 memAllocFailed = true;
961 if(memAllocFailed == true)
963 DU_LOG("\nERROR --> E2AP : Memory allocation for E2FailureIEs failed");
969 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
970 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
971 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TransactionID;
972 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
975 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
976 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
977 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_CauseE2;
978 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.present = CauseE2_PR_protocol;
979 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2.choice.protocol = CauseE2Protocol_unspecified;
982 e2SetupFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
983 e2SetupFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
984 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.present = E2setupFailureIEs__value_PR_TimeToWaitE2;
985 e2SetupFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
987 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
988 memset(encBuf, 0, ENC_BUF_MAX_LEN);
990 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
992 /* Check encode results */
993 if(encRetVal.encoded == ENCODE_FAIL)
995 DU_LOG("\nERROR --> E2AP : Could not encode E2 Setup failure structure (at %s)\n",\
996 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1001 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Setup Failure\n");
1002 for(int i=0; i< encBufSize; i++)
1004 DU_LOG("%x",encBuf[i]);
1008 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1010 DU_LOG("\nERROR --> E2AP : Sending E2 Setup Failure failed");
1016 FreeE2SetupFailure(e2apMsg);
1019 /*******************************************************************
1021 * @brief process the e2setup request
1025 * Function : ProcE2SetupReq
1027 * Functionality: process the e2setup request
1029 * @return ROK - success
1032 ******************************************************************/
1034 uint8_t ProcE2SetupReq(uint32_t *duId, E2setupRequest_t *e2SetupReq)
1036 uint8_t arrIdx = 0, e2NodeAddListIdx =0, duIdx = 0, transId =0, ranFuncIdx;
1038 E2nodeComponentConfigAddition_List_t *e2NodeAddList;
1039 E2nodeComponentConfigAddition_ItemIEs_t *e2NodeAddItem;
1040 RANfunction_ItemIEs_t *ranFuncItemIe;
1041 RANfunction_Item_t *ranFunItem;
1042 RANfunctions_List_t *ranFunctionsList;
1046 if(e2SetupReq->protocolIEs.list.array)
1048 for(arrIdx=0; arrIdx<e2SetupReq->protocolIEs.list.count; arrIdx++)
1050 if(e2SetupReq->protocolIEs.list.array[arrIdx])
1052 switch(e2SetupReq->protocolIEs.list.array[arrIdx]->id)
1054 case ProtocolIE_IDE2_id_TransactionID:
1056 transId = e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
1059 case ProtocolIE_IDE2_id_GlobalE2node_ID:
1061 if(e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID)
1063 *duId =e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.GlobalE2node_ID.choice.gNB->gNB_DU_ID->buf[0];
1065 SEARCH_DU_DB(duIdx, *duId, duDb);
1068 duDb = &ricCb.duInfo[ricCb.numDu];
1071 memset(duDb, 0, sizeof(DuDb));
1076 case ProtocolIE_IDE2_id_RANfunctionsAdded:
1079 ranFunctionsList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
1081 if(ranFunctionsList->list.array)
1083 for(ranFuncIdx=0;ranFuncIdx<ranFunctionsList->list.count; ranFuncIdx++)
1085 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFunctionsList->list.array[ranFuncIdx];
1086 ranFunItem = &ranFuncItemIe->value.choice.RANfunction_Item;
1087 duDb->ranFunction[ranFunItem->ranFunctionID-1].id = ranFunItem->ranFunctionID;
1088 duDb->ranFunction[ranFunItem->ranFunctionID-1].revisionCounter = ranFunItem->ranFunctionRevision;
1089 duDb->numOfRanFunction++;
1094 case ProtocolIE_IDE2_id_E2nodeComponentConfigAddition:
1096 e2NodeAddList = &e2SetupReq->protocolIEs.list.array[arrIdx]->value.choice.E2nodeComponentConfigAddition_List;
1097 if(e2NodeAddList->list.array)
1099 for(e2NodeAddListIdx = 0; e2NodeAddListIdx< e2NodeAddList->list.count; e2NodeAddListIdx++)
1101 if(e2NodeAddList->list.array[e2NodeAddListIdx])
1103 e2NodeAddItem = (E2nodeComponentConfigAddition_ItemIEs_t *) e2NodeAddList->list.array[e2NodeAddListIdx];
1104 if(e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.\
1105 e2nodeComponentInterfaceTypeF1)
1107 duDb->e2NodeComponent.interfaceType = F1;
1108 duDb->e2NodeComponent.componentId = e2NodeAddItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeF1->gNB_DU_ID.buf[0];
1123 if(BuildAndSendE2SetupRsp(duDb, transId) !=ROK)
1125 DU_LOG("\nERROR --> E2AP : Failed to build and send E2 setup response");
1131 /*******************************************************************
1133 * @brief Deallocate the memory allocated for E2nodeConfigurationUpdate msg
1137 * Function : FreeE2NodeConfigUpdate
1140 * - freeing the memory allocated for E2nodeConfigurationUpdate
1142 * @params[in] E2AP_PDU_t *e2apMsg
1143 * @return ROK - success
1146 * ****************************************************************/
1147 void FreeE2NodeConfigUpdateAck(E2AP_PDU_t *e2apMsg)
1150 E2nodeConfigurationUpdate_t *e2NodeConfigUpdateAck;
1152 if(e2apMsg != NULLP)
1154 if(e2apMsg->choice.successfulOutcome != NULLP)
1156 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1157 if(e2NodeConfigUpdateAck->protocolIEs.list.array != NULLP)
1159 for(arrIdx = 0; arrIdx < e2NodeConfigUpdateAck->protocolIEs.list.count; arrIdx++)
1161 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdate_t));
1163 RIC_FREE(e2NodeConfigUpdateAck->protocolIEs.list.array, e2NodeConfigUpdateAck->protocolIEs.list.size);
1165 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1167 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1171 /*******************************************************************
1173 * @brief Buld and send the E2 node config update msg
1177 * Function : BuildAndSendE2NodeConfigUpdate
1180 * - Buld and send the E2 node config update msg
1181 * @return ROK - success
1184 * ****************************************************************/
1186 uint8_t BuildAndSendE2NodeConfigUpdateAck(uint32_t duId)
1188 uint8_t arrIdx = 0,elementCnt = 1;
1190 E2AP_PDU_t *e2apMsg = NULLP;
1191 E2nodeConfigurationUpdateAcknowledge_t *e2NodeConfigUpdateAck = NULLP;
1192 asn_enc_rval_t encRetVal; /* Encoder return value */
1194 DU_LOG("\nINFO --> E2AP : Building E2 Node config update Ack Message\n");
1197 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1198 if(e2apMsg == NULLP)
1200 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1203 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1204 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1205 if(e2apMsg->choice.successfulOutcome == NULLP)
1207 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1208 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1212 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1213 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_E2nodeConfigurationUpdate;
1214 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_E2nodeConfigurationUpdateAcknowledge;
1215 e2NodeConfigUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.E2nodeConfigurationUpdateAcknowledge;
1217 e2NodeConfigUpdateAck->protocolIEs.list.count = elementCnt;
1218 e2NodeConfigUpdateAck->protocolIEs.list.size = elementCnt * sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t*);
1219 /* Initialize the Ric Indication members */
1220 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array, \
1221 e2NodeConfigUpdateAck->protocolIEs.list.size);
1222 if(e2NodeConfigUpdateAck->protocolIEs.list.array == NULLP)
1224 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1228 for(arrIdx =0; arrIdx<elementCnt; arrIdx++)
1230 RIC_ALLOC(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx], sizeof(E2nodeConfigurationUpdateAcknowledge_IEs_t));
1231 if(e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
1234 DU_LOG("\nERROR --> E2AP : Memory allocation for e2NodeConfigUpdateAck failed");
1241 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1242 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1243 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.present = E2nodeConfigurationUpdateAcknowledge_IEs__value_PR_TransactionID;
1244 e2NodeConfigUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = TRANS_ID;
1247 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1249 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1251 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
1253 if(encRetVal.encoded == ENCODE_FAIL)
1255 DU_LOG("\nERROR --> E2AP : Could not encode E2 Node config update ack structure (at %s)\n",\
1256 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1261 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Node config update ack \n");
1262 for(int i=0; i< encBufSize; i++)
1264 DU_LOG("%x",encBuf[i]);
1270 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1272 DU_LOG("\nERROR --> E2AP : Failed to send E2 Node config update ack ");
1279 FreeE2NodeConfigUpdateAck(e2apMsg);
1283 /*******************************************************************
1285 * @brief Deallocate the memory allocated for E2 Reset Response
1289 * Function : FreeE2ResetResponse
1292 * - freeing the memory allocated for E2ResetResponse
1294 * @params[in] E2AP_PDU_t *e2apMsg
1295 * @return ROK - success
1298 * ****************************************************************/
1299 void FreeE2ResetResponse(E2AP_PDU_t *e2apMsg)
1302 ResetResponseE2_t *resetResponse;
1304 if(e2apMsg != NULLP)
1306 if(e2apMsg->choice.successfulOutcome != NULLP)
1308 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1309 if(resetResponse->protocolIEs.list.array)
1311 for(ieIdx=0; ieIdx < resetResponse->protocolIEs.list.count; ieIdx++)
1313 if(resetResponse->protocolIEs.list.array[ieIdx])
1315 RIC_FREE(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1318 RIC_FREE(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1320 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1322 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1326 /*******************************************************************
1328 * @brief Buld and send the E2 Reset Response msg
1332 * Function : BuildAndSendE2ResetResponse
1335 * - Buld and send the E2 Reset Response Message
1336 * @return ROK - success
1339 * ****************************************************************/
1340 uint8_t BuildAndSendResetResponse(uint32_t duId, uint8_t transId)
1342 uint8_t ieIdx = 0, elementCnt = 0;
1343 uint8_t ret = RFAILED;
1344 E2AP_PDU_t *e2apMsg = NULLP;
1345 ResetResponseE2_t *resetResponse;
1346 asn_enc_rval_t encRetVal; /* Encoder return value */
1348 DU_LOG("\nINFO --> E2AP : Building E2 Reset Response Message\n");
1351 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1352 if(e2apMsg == NULLP)
1354 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse(): Memory allocation for E2AP-PDU failed");
1357 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
1359 RIC_ALLOC(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1360 if(e2apMsg->choice.successfulOutcome == NULLP)
1362 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for successfulOutcome");
1363 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1367 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_Reset;
1368 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
1369 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_ResetResponseE2;
1370 resetResponse = &e2apMsg->choice.successfulOutcome->value.choice.ResetResponseE2;
1373 resetResponse->protocolIEs.list.count = elementCnt;
1374 resetResponse->protocolIEs.list.size = elementCnt * sizeof(ResetResponseIEs_t *);
1375 RIC_ALLOC(resetResponse->protocolIEs.list.array, resetResponse->protocolIEs.list.size);
1376 if(!resetResponse->protocolIEs.list.array)
1378 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array");
1382 for(ieIdx=0; ieIdx < elementCnt; ieIdx++)
1384 RIC_ALLOC(resetResponse->protocolIEs.list.array[ieIdx], sizeof(ResetResponseIEs_t));
1385 if(!resetResponse->protocolIEs.list.array[ieIdx])
1387 DU_LOG("\nERROR --> E2AP : BuildAndSendResetResponse: Memory allocation failed for protocol IE array element");
1391 if(ieIdx < elementCnt)
1395 resetResponse->protocolIEs.list.array[ieIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1396 resetResponse->protocolIEs.list.array[ieIdx]->criticality = CriticalityE2_reject;
1397 resetResponse->protocolIEs.list.array[ieIdx]->value.present = ResetResponseIEs__value_PR_TransactionID;
1398 resetResponse->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = transId;
1400 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1402 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1404 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1405 if(encRetVal.encoded == ENCODE_FAIL)
1407 DU_LOG("\nERROR --> E2AP : Could not encode E2 reset response structure (at %s)\n",\
1408 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1413 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for E2 Reset Response \n");
1414 for(int i=0; i< encBufSize; i++)
1416 DU_LOG("%x",encBuf[i]);
1421 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1423 DU_LOG("\nERROR --> E2AP : Failed to send E2 Reset Response");
1431 FreeE2ResetResponse(e2apMsg);
1435 /*******************************************************************
1437 * @brief process the E2 Reset Request
1441 * Function : ProcE2ResetReq
1443 * Functionality: Process E2 Reset Request
1445 * @return ROK - success
1448 ******************************************************************/
1450 uint8_t ProcE2ResetReq(uint32_t duId, ResetRequestE2_t *resetReq)
1452 uint8_t ieIdx = 0, duIdx = 0;
1453 uint8_t transId = 0, cause = 0;
1458 if(resetReq->protocolIEs.list.array)
1460 for(ieIdx=0; ieIdx < resetReq->protocolIEs.list.count; ieIdx++)
1462 if(resetReq->protocolIEs.list.array[ieIdx])
1464 switch(resetReq->protocolIEs.list.array[ieIdx]->id)
1466 case ProtocolIE_IDE2_id_TransactionID:
1467 transId = resetReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
1469 case ProtocolIE_IDE2_id_CauseE2:
1470 DU_LOG("\nDEBUG --> E2AP : Reset reason %d", resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present);
1471 switch(resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.present)
1473 case CauseE2_PR_NOTHING:
1475 case CauseE2_PR_ricRequest:
1476 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricRequest;
1478 case CauseE2_PR_ricService:
1479 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.ricService;
1481 case CauseE2_PR_e2Node:
1482 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.e2Node;
1484 case CauseE2_PR_transport:
1485 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.transport;
1487 case CauseE2_PR_protocol:
1488 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.protocol;
1490 case CauseE2_PR_misc:
1491 cause = resetReq->protocolIEs.list.array[ieIdx]->value.choice.CauseE2.choice.misc;
1494 DU_LOG("\nDEBUG --> E2AP : Reset cause %d", cause);
1501 BuildAndSendResetResponse(duId, transId);
1505 /*******************************************************************
1507 * @brief deallocate the memory allocated in building the
1508 * Service Query message
1512 * Function : FreeRicServiceQuery
1514 * Functionality: deallocate the memory allocated in building
1515 * Ric Service Query message
1517 * @params[in] E2AP_PDU_t *e2apMsg
1520 * ****************************************************************/
1522 void FreeRicServiceQuery(E2AP_PDU_t *e2apMsg)
1524 uint8_t arrIdx = 0, ranFuncIdx=0;
1525 RANfunctionsID_List_t *ranFuncAcceptedList=NULL;
1526 RICserviceQuery_t *ricServiceQuery=NULL;
1530 if(e2apMsg->choice.initiatingMessage)
1532 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
1533 if(ricServiceQuery->protocolIEs.list.array)
1535 for(arrIdx=0; arrIdx<ricServiceQuery->protocolIEs.list.count; arrIdx++)
1537 if(ricServiceQuery->protocolIEs.list.array[arrIdx])
1539 switch(ricServiceQuery->protocolIEs.list.array[arrIdx]->id)
1541 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1543 ranFuncAcceptedList= &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1544 if(ranFuncAcceptedList->list.array)
1546 for(ranFuncIdx=0;ranFuncIdx<ranFuncAcceptedList->list.count; ranFuncIdx++)
1548 RIC_FREE(ranFuncAcceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1550 RIC_FREE(ranFuncAcceptedList->list.array, ranFuncAcceptedList->list.size);
1554 case RICserviceQuery_IEs__value_PR_TransactionID:
1559 RIC_FREE(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
1562 RIC_FREE(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
1564 RIC_FREE(e2apMsg->choice.initiatingMessage, sizeof(InitiatingMessageE2_t));
1566 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1570 /*******************************************************************
1572 * @brief build and send the ric service Query
1576 * Function : BuildAndSendRicServiceQuery
1578 * Functionality: build and send the ric service Query
1579 * @return ROK - success
1580 * RFAILED - Acknowledge
1582 ******************************************************************/
1584 uint8_t BuildAndSendRicServiceQuery(DuDb *duDb)
1588 uint8_t ret = RFAILED;
1589 bool memAllocFailed = false;
1590 E2AP_PDU_t *e2apMsg = NULL;
1591 asn_enc_rval_t encRetVal;
1592 RICserviceQuery_t *ricServiceQuery;
1594 DU_LOG("\nINFO --> E2AP : Building Ric service Query\n");
1597 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1598 if(e2apMsg == NULLP)
1600 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1603 e2apMsg->present = E2AP_PDU_PR_initiatingMessage;
1604 RIC_ALLOC(e2apMsg->choice.initiatingMessage , sizeof(struct InitiatingMessageE2));
1605 if(e2apMsg->choice.initiatingMessage == NULLP)
1607 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1611 e2apMsg->choice.initiatingMessage->procedureCode = ProcedureCodeE2_id_RICserviceQuery;
1612 e2apMsg->choice.initiatingMessage->criticality = CriticalityE2_reject;
1613 e2apMsg->choice.initiatingMessage->value.present = InitiatingMessageE2__value_PR_RICserviceQuery;
1614 ricServiceQuery = &e2apMsg->choice.initiatingMessage->value.choice.RICserviceQuery;
1617 /* Fill Accepted RAN function IE If Ran function information is stored in databse */
1618 if(duDb->numOfRanFunction)
1621 ricServiceQuery->protocolIEs.list.count = elementCnt;
1622 ricServiceQuery->protocolIEs.list.size = elementCnt * sizeof(RICserviceQuery_IEs_t*);
1624 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array, ricServiceQuery->protocolIEs.list.size);
1625 if(ricServiceQuery->protocolIEs.list.array == NULLP)
1627 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
1631 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
1633 RIC_ALLOC(ricServiceQuery->protocolIEs.list.array[arrIdx], sizeof(RICserviceQuery_IEs_t));
1634 if(ricServiceQuery->protocolIEs.list.array[arrIdx] == NULLP)
1636 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
1637 memAllocFailed = true;
1641 if(memAllocFailed == true)
1643 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceQueryIEs failed");
1649 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1650 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1651 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_TransactionID;
1652 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = assignTransactionId(duDb);
1654 if(duDb->numOfRanFunction)
1656 /* Accepted RAN function Id */
1658 ricServiceQuery->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
1659 ricServiceQuery->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1660 ricServiceQuery->protocolIEs.list.array[arrIdx]->value.present = RICserviceQuery_IEs__value_PR_RANfunctionsID_List;
1661 if(BuildRanFunctionAcceptedList(duDb, 0, NULL, &ricServiceQuery->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceQuery)!=ROK)
1663 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
1668 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1669 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1671 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1673 /* Check encode results */
1674 if(encRetVal.encoded == ENCODE_FAIL)
1676 DU_LOG("\nERROR --> E2AP : Could not encode RIC service Query structure (at %s)\n",\
1677 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1682 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service Query\n");
1683 for(int i=0; i< encBufSize; i++)
1685 DU_LOG("%x",encBuf[i]);
1689 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
1691 DU_LOG("\nERROR --> E2AP : Sending of RIC service Query failed");
1698 FreeRicServiceQuery(e2apMsg);
1702 /*******************************************************************
1704 * @brief deallocate the memory allocated in RicServiceUpdateFailure
1708 * Function : FreeRicServiceUpdateFailure
1710 * Functionality: deallocate the memory allocated in RicServiceUpdatefailure
1712 * @params[in] E2AP_PDU_t *e2apMsg
1715 * ****************************************************************/
1717 void FreeRicServiceUpdateFailure(E2AP_PDU_t *e2apMsg)
1720 RICserviceUpdateFailure_t *ricServiceUpdateFailure=NULL;
1724 if(e2apMsg->choice.unsuccessfulOutcome)
1726 ricServiceUpdateFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
1727 if(ricServiceUpdateFailure->protocolIEs.list.array)
1729 for(arrIdx=0; arrIdx<ricServiceUpdateFailure->protocolIEs.list.count; arrIdx++)
1731 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
1733 RIC_FREE(ricServiceUpdateFailure->protocolIEs.list.array, ricServiceUpdateFailure->protocolIEs.list.size);
1735 RIC_FREE(e2apMsg->choice.unsuccessfulOutcome, sizeof(UnsuccessfulOutcomeE2_t));
1737 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1741 /*******************************************************************
1743 * @brief fill E2 failure cause
1747 * Function : fillE2FailureCause
1749 * Functionality: fill E2 failure cause
1750 * @return ROK - success
1753 ******************************************************************/
1755 void fillE2FailureCause(CauseE2_t *cause, CauseE2_PR causePresent, uint8_t reason)
1757 cause->present = causePresent;
1759 switch(cause->present)
1761 case CauseE2_PR_ricRequest:
1762 cause->choice.ricRequest = reason;
1764 case CauseE2_PR_ricService:
1765 cause->choice.ricService = reason;
1767 case CauseE2_PR_e2Node:
1768 cause->choice.e2Node = reason;
1770 case CauseE2_PR_transport:
1771 cause->choice.transport = reason;
1773 case CauseE2_PR_protocol:
1774 cause->choice.protocol = reason;
1776 case CauseE2_PR_misc:
1777 cause->choice.misc = reason;
1780 cause->choice.misc = CauseE2Misc_unspecified;
1785 /*******************************************************************
1787 * @brief build and send the ric service update failure
1791 * Function : BuildAndSendRicServiceUpdateFailure
1793 * Functionality: build and send the ric service update failure
1794 * @return ROK - success
1797 ******************************************************************/
1799 uint8_t BuildAndSendRicServiceUpdateFailure(uint32_t duId, int8_t transId, CauseE2_PR causePresent, uint8_t reason)
1802 E2AP_PDU_t *e2apMsg = NULL;
1803 asn_enc_rval_t encRetVal;
1804 uint8_t ret = RFAILED;
1806 uint8_t elementCnt=0;
1807 RICserviceUpdateFailure_t *ricServiceFailure=NULL;
1809 DU_LOG("\nINFO --> E2AP : Building Ric service update failure\n");
1812 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
1813 if(e2apMsg == NULLP)
1815 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1818 e2apMsg->present = E2AP_PDU_PR_unsuccessfulOutcome;
1819 RIC_ALLOC(e2apMsg->choice.unsuccessfulOutcome , sizeof(struct UnsuccessfulOutcomeE2));
1820 if(e2apMsg->choice.unsuccessfulOutcome == NULLP)
1822 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
1826 e2apMsg->choice.unsuccessfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
1827 e2apMsg->choice.unsuccessfulOutcome->criticality = CriticalityE2_reject;
1828 e2apMsg->choice.unsuccessfulOutcome->value.present = UnsuccessfulOutcomeE2__value_PR_RICserviceUpdateFailure;
1829 ricServiceFailure = &e2apMsg->choice.unsuccessfulOutcome->value.choice.RICserviceUpdateFailure;
1832 ricServiceFailure->protocolIEs.list.count = elementCnt;
1833 ricServiceFailure->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateFailure_IEs_t *);
1835 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array, ricServiceFailure->protocolIEs.list.size);
1836 if(ricServiceFailure->protocolIEs.list.array == NULLP)
1838 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
1842 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
1844 RIC_ALLOC(ricServiceFailure->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateFailure_IEs_t));
1845 if(ricServiceFailure->protocolIEs.list.array[arrIdx] == NULLP)
1847 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
1851 if(arrIdx<elementCnt)
1853 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceFailureIEs failed");
1859 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
1860 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1861 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TransactionID;
1862 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
1865 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_CauseE2;
1866 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
1867 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_CauseE2;
1868 fillE2FailureCause(&ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.CauseE2, causePresent, reason);
1871 ricServiceFailure->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TimeToWaitE2;
1872 ricServiceFailure->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_ignore;
1873 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateFailure_IEs__value_PR_TimeToWaitE2;
1874 ricServiceFailure->protocolIEs.list.array[arrIdx]->value.choice.TimeToWaitE2 = TimeToWaitE2_v5s;
1876 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
1877 memset(encBuf, 0, ENC_BUF_MAX_LEN);
1879 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
1881 /* Check encode results */
1882 if(encRetVal.encoded == ENCODE_FAIL)
1884 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update failure structure (at %s)\n",\
1885 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1890 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Failure\n");
1891 for(int i=0; i< encBufSize; i++)
1893 DU_LOG("%x",encBuf[i]);
1897 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duId) != ROK)
1899 DU_LOG("\nERROR --> E2AP : Sending RIC service update failed");
1906 FreeRicServiceUpdateFailure(e2apMsg);
1911 /*******************************************************************
1913 * @brief deallocate the memory allocated in RicServiceUpdateAck(
1917 * Function : FreeRicServiceUpdateAck
1919 * Functionality: deallocate the memory allocated in RicServiceUpdateAck
1921 * @params[in] E2AP_PDU_t *e2apMsg
1924 * ****************************************************************/
1926 void FreeRicServiceUpdateAck(E2AP_PDU_t *e2apMsg)
1928 uint8_t arrIdx = 0, ranFuncIdx=0;
1929 RANfunctionsID_List_t *acceptedList=NULL;
1930 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
1931 RANfunctionsIDcause_List_t *rejectedList=NULL;
1935 if(e2apMsg->choice.successfulOutcome)
1937 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
1938 if(ricServiceUpdateAck->protocolIEs.list.array)
1940 for(arrIdx=0; arrIdx<ricServiceUpdateAck->protocolIEs.list.count; arrIdx++)
1942 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx])
1944 switch(ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id)
1946 case ProtocolIE_IDE2_id_RANfunctionsAccepted:
1948 acceptedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
1949 if(acceptedList->list.array)
1951 for(ranFuncIdx=0;ranFuncIdx<acceptedList->list.count; ranFuncIdx++)
1953 RIC_FREE(acceptedList->list.array[ranFuncIdx], sizeof(RANfunction_ItemIEs_t));
1955 RIC_FREE(acceptedList->list.array, acceptedList->list.size);
1960 case ProtocolIE_IDE2_id_RANfunctionsRejected:
1962 rejectedList= &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List;
1963 if(rejectedList->list.array)
1965 for(ranFuncIdx=0;ranFuncIdx<rejectedList->list.count; ranFuncIdx++)
1967 RIC_FREE(rejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
1969 RIC_FREE(rejectedList->list.array, rejectedList->list.size);
1974 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
1977 RIC_FREE(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
1979 RIC_FREE(e2apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcomeE2_t));
1981 RIC_FREE(e2apMsg, sizeof(E2AP_PDU_t));
1985 /*******************************************************************
1987 * @brief Build RAN function rejected list
1991 * Function : BuildRanFunctionRejectedList
1993 * Functionality: Build RAN function rejected list
1996 * Count of ran functions to be rejected in the list
1997 * Received list of RAN functions
1999 * @return ROK - success
2001 * ****************************************************************/
2003 uint8_t BuildRanFunctionRejectedList(uint8_t count, RanFunction *ranFunRejectedList, RANfunctionsIDcause_List_t *ranFuncRejectedList)
2005 uint8_t ranFuncIdx = 0;
2006 RANfunctionIDcause_ItemIEs_t *ranFuncRejectedItemIe=NULL;
2008 ranFuncRejectedList->list.count = count;
2010 ranFuncRejectedList->list.size = ranFuncRejectedList->list.count*sizeof(RANfunctionIDcause_ItemIEs_t*);
2011 RIC_ALLOC(ranFuncRejectedList->list.array, ranFuncRejectedList->list.size);
2012 if(ranFuncRejectedList->list.array == NULLP)
2014 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array");
2018 for(ranFuncIdx = 0; ranFuncIdx< ranFuncRejectedList->list.count; ranFuncIdx++)
2020 RIC_ALLOC(ranFuncRejectedList->list.array[ranFuncIdx], sizeof(RANfunctionIDcause_ItemIEs_t));
2021 if(ranFuncRejectedList->list.array[ranFuncIdx] == NULLP)
2023 DU_LOG("\nERROR --> E2AP : Memory allocation for RAN function rejected list array item");
2026 ranFuncRejectedItemIe = (RANfunctionIDcause_ItemIEs_t*)ranFuncRejectedList->list.array[ranFuncIdx];
2027 ranFuncRejectedItemIe->id = ProtocolIE_IDE2_id_RANfunctionID_Item;
2028 ranFuncRejectedItemIe->criticality= CriticalityE2_ignore;
2029 ranFuncRejectedItemIe->value.present = RANfunctionIDcause_ItemIEs__value_PR_RANfunctionIDcause_Item;
2030 ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.ranFunctionID = ranFunRejectedList[ranFuncIdx].id;
2031 fillE2FailureCause(&ranFuncRejectedItemIe->value.choice.RANfunctionIDcause_Item.cause, CauseE2_PR_ricService,\
2032 CauseE2RICservice_ran_function_not_supported);
2038 /*******************************************************************
2040 * @brief build and send the ric service update Acknowledge
2044 * Function : BuildAndSendRicServiceUpdateAcknowledge
2046 * Functionality: build and send the ric service update Acknowledge
2047 * @return ROK - success
2048 * RFAILED - Acknowledge
2050 ******************************************************************/
2052 uint8_t BuildAndSendRicServiceUpdateAcknowledge(DuDb *duDb, int8_t transId, RicTmpRanFunList ricRanFuncList)
2054 E2AP_PDU_t *e2apMsg = NULL;
2055 asn_enc_rval_t encRetVal;
2056 uint8_t arrIdx=0, elementCnt=0, ret=RFAILED;;
2057 RICserviceUpdateAcknowledge_t *ricServiceUpdateAck=NULL;
2059 DU_LOG("\nINFO --> E2AP : Building Ric service update Acknowledge\n");
2062 RIC_ALLOC(e2apMsg, sizeof(E2AP_PDU_t));
2063 if(e2apMsg == NULLP)
2065 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2068 e2apMsg->present = E2AP_PDU_PR_successfulOutcome;
2069 RIC_ALLOC(e2apMsg->choice.successfulOutcome , sizeof(struct SuccessfulOutcomeE2));
2070 if(e2apMsg->choice.successfulOutcome == NULLP)
2072 DU_LOG("\nERROR --> E2AP : Memory allocation for E2AP-PDU failed");
2076 e2apMsg->choice.successfulOutcome->procedureCode = ProcedureCodeE2_id_RICserviceUpdate;
2077 e2apMsg->choice.successfulOutcome->criticality = CriticalityE2_reject;
2078 e2apMsg->choice.successfulOutcome->value.present = SuccessfulOutcomeE2__value_PR_RICserviceUpdateAcknowledge;
2079 ricServiceUpdateAck = &e2apMsg->choice.successfulOutcome->value.choice.RICserviceUpdateAcknowledge;
2082 if(ricRanFuncList.numOfRanFunAccepted)
2084 if(ricRanFuncList.numOfRanFuneRejected)
2088 ricServiceUpdateAck->protocolIEs.list.count = elementCnt;
2089 ricServiceUpdateAck->protocolIEs.list.size = elementCnt * sizeof(RICserviceUpdateAcknowledge_IEs_t*);
2091 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array, ricServiceUpdateAck->protocolIEs.list.size);
2092 if(ricServiceUpdateAck->protocolIEs.list.array == NULLP)
2094 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2098 for(arrIdx=0; arrIdx<elementCnt; arrIdx++)
2100 RIC_ALLOC(ricServiceUpdateAck->protocolIEs.list.array[arrIdx], sizeof(RICserviceUpdateAcknowledge_IEs_t));
2101 if(ricServiceUpdateAck->protocolIEs.list.array[arrIdx] == NULLP)
2103 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2107 if(arrIdx<elementCnt)
2109 DU_LOG("\nERROR --> E2AP : Memory allocation for ricServiceUpdateAckIEs failed");
2115 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_TransactionID;
2116 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2117 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_TransactionID;
2118 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.TransactionID = transId;
2120 if(ricRanFuncList.numOfRanFunAccepted)
2122 /* Accepted RAN function List */
2124 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsAccepted;
2125 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2126 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsID_List;
2127 if(BuildRanFunctionAcceptedList(duDb, ricRanFuncList.numOfRanFunAccepted, ricRanFuncList.ranFunAcceptedList,\
2128 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List, ProcedureCodeE2_id_RICserviceUpdate)!=ROK)
2130 DU_LOG("\nERROR --> E2AP : Failed to build Ran function added list");
2135 if(ricRanFuncList.numOfRanFuneRejected)
2137 /* RAN Functions Rejected List */
2139 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->id = ProtocolIE_IDE2_id_RANfunctionsRejected;
2140 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->criticality = CriticalityE2_reject;
2141 ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.present = RICserviceUpdateAcknowledge_IEs__value_PR_RANfunctionsIDcause_List;
2142 if(BuildRanFunctionRejectedList(ricRanFuncList.numOfRanFuneRejected, ricRanFuncList.ranFunRejectedList, \
2143 &ricServiceUpdateAck->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsIDcause_List)!=ROK)
2145 DU_LOG("\nERROR --> E2AP : Failed to build Ran function rejected list");
2151 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2152 memset(encBuf, 0, ENC_BUF_MAX_LEN);
2154 encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
2156 /* Check encode results */
2157 if(encRetVal.encoded == ENCODE_FAIL)
2159 DU_LOG("\nERROR --> E2AP : Could not encode RIC service update Acknowledge structure (at %s)\n",\
2160 encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2165 DU_LOG("\nDEBUG --> E2AP : Created APER encoded buffer for RIC service update Acknowledge\n");
2166 for(int i=0; i< encBufSize; i++)
2168 DU_LOG("%x",encBuf[i]);
2172 if(SendE2APMsg(RIC_APP_MEM_REG, RIC_POOL, duDb->duId) != ROK)
2174 DU_LOG("\nERROR --> E2AP : Sending RIC service update ack failed");
2180 FreeRicServiceUpdateAck(e2apMsg);
2184 /*******************************************************************
2186 * @brief process the RIC service update
2190 * Function : ProcRicserviceUpdate
2192 * Functionality: process the RIC service update
2194 * @return ROK - success
2197 ******************************************************************/
2199 void ProcRicServiceUpdate(uint32_t duId, RICserviceUpdate_t *ricServiceUpdate)
2201 RicTmpRanFunList ricRanFuncList;
2204 uint8_t duIdx = 0, elementCnt =0, arrIdx = 0;
2205 uint16_t ranFuncIdx = 0, failedRanFuncCount=0, recvdRanFuncCount=0;
2206 RANfunction_ItemIEs_t *ranFuncItemIe =NULL;
2207 RANfunction_Item_t *ranFuncItem =NULL;
2208 RANfunctionID_Item_t *ranFuncIdItem=NULL;
2209 RANfunctions_List_t *ranFuncList=NULL;
2210 RANfunctionsID_List_t *deleteList=NULL;
2211 RANfunctionID_ItemIEs_t *delRanFuncItem=NULL;
2213 SEARCH_DU_DB(duIdx, duId, duDb);
2216 DU_LOG("\nERROR --> E2AP : duDb is not present for duId %d",duId);
2219 memset(&ricRanFuncList, 0, sizeof(RicTmpRanFunList));
2221 if(!ricServiceUpdate)
2223 DU_LOG("\nERROR --> E2AP : ricServiceUpdate pointer is null");
2227 if(!ricServiceUpdate->protocolIEs.list.array)
2229 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array pointer is null");
2232 elementCnt = ricServiceUpdate->protocolIEs.list.count;
2233 for(arrIdx=0; arrIdx<ricServiceUpdate->protocolIEs.list.count; arrIdx++)
2235 if(!ricServiceUpdate->protocolIEs.list.array[arrIdx])
2237 DU_LOG("\nERROR --> E2AP : ricServiceUpdate array idx %d pointer is null",arrIdx);
2241 switch(ricServiceUpdate->protocolIEs.list.array[arrIdx]->id)
2243 case ProtocolIE_IDE2_id_TransactionID:
2245 transId = ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.TransactionID;
2247 if(transId < 0 || transId > 255)
2249 DU_LOG("\nERROR --> E2AP : Received invalid transId %d",transId);
2255 case ProtocolIE_IDE2_id_RANfunctionsAdded:
2257 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2259 if(ranFuncList->list.array)
2261 for(ranFuncIdx=0;ranFuncIdx<ranFuncList->list.count; ranFuncIdx++)
2263 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2264 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2266 /* Adding the ran function in temporary list */
2267 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2268 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2269 ricRanFuncList.numOfRanFunAccepted++;
2271 /* Adding the new ran function in DB*/
2272 duDb->ranFunction[ranFuncItem->ranFunctionID-1].id = ranFuncItem->ranFunctionID;
2273 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2274 duDb->numOfRanFunction++;
2276 /* Calculating total number of ran fuctions which are received for addition */
2277 recvdRanFuncCount++;
2283 case ProtocolIE_IDE2_id_RANfunctionsModified:
2286 ranFuncList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctions_List;
2287 if(ranFuncList->list.array)
2289 for(ranFuncIdx = 0; ranFuncIdx< ranFuncList->list.count; ranFuncIdx++)
2291 ranFuncItemIe = (RANfunction_ItemIEs_t *) ranFuncList->list.array[ranFuncIdx];
2292 ranFuncItem = &ranFuncItemIe->value.choice.RANfunction_Item;
2293 if(duDb->ranFunction[ranFuncItem->ranFunctionID-1].id != ranFuncItem->ranFunctionID)
2295 /* Calculating total number of ran fuctions which are not present */
2296 failedRanFuncCount++;
2298 /* Adding the ran function in temporary list */
2299 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
2300 ricRanFuncList.numOfRanFuneRejected++;
2305 /* Adding the ran function in temporary list */
2306 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].id = ranFuncItem->ranFunctionID;
2307 ricRanFuncList.ranFunAcceptedList[ricRanFuncList.numOfRanFunAccepted].revisionCounter = ranFuncItem->ranFunctionRevision;
2308 ricRanFuncList.numOfRanFunAccepted++;
2310 /* Updating the new ran function in DB*/
2311 duDb->ranFunction[ranFuncItem->ranFunctionID-1].revisionCounter = ranFuncItem->ranFunctionRevision;
2313 /* Calculating total number of ran fuctions which are received for modification */
2314 recvdRanFuncCount++;
2319 case ProtocolIE_IDE2_id_RANfunctionsDeleted:
2322 deleteList = &ricServiceUpdate->protocolIEs.list.array[arrIdx]->value.choice.RANfunctionsID_List;
2323 if(deleteList->list.array)
2325 for(ranFuncIdx = 0; ranFuncIdx< deleteList->list.count; ranFuncIdx++)
2327 delRanFuncItem = (RANfunctionID_ItemIEs_t*) deleteList->list.array[ranFuncIdx];
2328 ranFuncIdItem = &delRanFuncItem->value.choice.RANfunctionID_Item;
2329 if(duDb->ranFunction[ranFuncIdItem->ranFunctionID-1].id != ranFuncIdItem->ranFunctionID)
2331 /* Calculating total number of ran fuctions which are not present */
2332 failedRanFuncCount++;
2334 /* Adding the ran function in temporary list */
2335 ricRanFuncList.ranFunRejectedList[ricRanFuncList.numOfRanFuneRejected].id = ranFuncItem->ranFunctionID;
2336 ricRanFuncList.numOfRanFuneRejected++;
2340 memset(&duDb->ranFunction[ranFuncIdItem->ranFunctionID-1], 0, sizeof(RanFunction));
2341 duDb->numOfRanFunction--;
2344 /* Calculating total number of ran fuctions which are received for deletion */
2345 recvdRanFuncCount++;
2353 DU_LOG("\nERROR --> E2AP : IE [%ld] is not supported",ricServiceUpdate->protocolIEs.list.array[arrIdx]->id);
2359 /* Sending RIC Service Update Failed if all RAN Functions received fail or if any IE processing fails
2360 * Else sending RIC Service Update Acknowledge */
2361 if((elementCnt > arrIdx) ||((recvdRanFuncCount > 0) && (recvdRanFuncCount == failedRanFuncCount)))
2363 if(BuildAndSendRicServiceUpdateFailure(duDb->duId, transId, CauseE2_PR_misc, CauseE2Misc_unspecified) != ROK)
2365 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update Failure");
2371 if(BuildAndSendRicServiceUpdateAcknowledge(duDb, transId, ricRanFuncList) != ROK)
2373 DU_LOG("\nERROR --> E2AP : Failed to build and send RIC service update acknowledge");
2380 /*******************************************************************
2382 * @brief Handles received E2AP message and sends back response
2386 * Function : E2APMsgHdlr
2389 * - Decodes received E2AP control message
2390 * - Prepares response message, encodes and sends to SCTP
2393 * @return ROK - success
2396 * ****************************************************************/
2397 void E2APMsgHdlr(uint32_t *duId, Buffer *mBuf)
2403 E2AP_PDU_t *e2apMsg;
2404 asn_dec_rval_t rval; /* Decoder return value */
2405 E2AP_PDU_t e2apasnmsg ;
2407 DU_LOG("\nINFO --> E2AP : Received E2AP message buffer");
2408 ODU_PRINT_MSG(mBuf, 0,0);
2410 /* Copy mBuf into char array to decode it */
2411 ODU_GET_MSG_LEN(mBuf, &recvBufLen);
2412 RIC_ALLOC(recvBuf, (Size)recvBufLen);
2414 if(recvBuf == NULLP)
2416 DU_LOG("\nERROR --> E2AP : Memory allocation failed");
2419 if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
2421 DU_LOG("\nERROR --> E2AP : Failed while copying %d", copyCnt);
2425 DU_LOG("\nDEBUG --> E2AP : Received flat buffer to be decoded : ");
2426 for(i=0; i< recvBufLen; i++)
2428 DU_LOG("%x",recvBuf[i]);
2431 /* Decoding flat buffer into E2AP messsage */
2432 e2apMsg = &e2apasnmsg;
2433 memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
2435 rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
2436 RIC_FREE(recvBuf, (Size)recvBufLen);
2438 if(rval.code == RC_FAIL || rval.code == RC_WMORE)
2440 DU_LOG("\nERROR --> E2AP : ASN decode failed");
2444 xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
2446 switch(e2apMsg->present)
2448 case E2AP_PDU_PR_initiatingMessage:
2450 switch(e2apMsg->choice.initiatingMessage->value.present)
2452 case InitiatingMessageE2__value_PR_E2setupRequest:
2454 DU_LOG("\nINFO --> E2AP : E2 setup request received");
2455 ProcE2SetupReq(duId, &e2apMsg->choice.initiatingMessage->value.choice.E2setupRequest);
2458 case InitiatingMessageE2__value_PR_E2nodeConfigurationUpdate:
2460 DU_LOG("\nINFO --> E2AP : E2 node config update received");
2461 BuildAndSendE2NodeConfigUpdateAck(*duId);
2464 case InitiatingMessageE2__value_PR_ResetRequestE2:
2466 DU_LOG("\nINFO --> E2AP : E2 Reset Request received");
2467 ProcE2ResetReq(*duId, &e2apMsg->choice.initiatingMessage->value.choice.ResetRequestE2);
2470 case InitiatingMessageE2__value_PR_RICindication:
2472 DU_LOG("\nINFO --> E2AP : RIC Indication Acknowledged");
2475 case InitiatingMessageE2__value_PR_RICserviceUpdate:
2477 DU_LOG("\nINFO --> E2AP : RIC Service update received");
2478 ProcRicServiceUpdate(*duId, &e2apMsg->choice.initiatingMessage->value.choice.RICserviceUpdate);
2484 DU_LOG("\nERROR --> E2AP : Invalid type of intiating message [%d]",e2apMsg->choice.initiatingMessage->value.present);
2487 }/* End of switch(initiatingMessage) */
2490 case E2AP_PDU_PR_successfulOutcome:
2492 switch(e2apMsg->choice.successfulOutcome->value.present)
2494 case SuccessfulOutcomeE2__value_PR_RICsubscriptionResponse:
2496 ProcRicSubscriptionResponse(*duId);
2501 DU_LOG("\nERROR --> E2AP : Invalid type of successfulOutcome message [%d]",e2apMsg->choice.successfulOutcome->value.present);
2510 DU_LOG("\nERROR --> E2AP : Invalid type message type ");
2514 }/* End of switch(e2apMsg->present) */
2515 } /* End of E2APMsgHdlr */
2518 /**********************************************************************
2520 **********************************************************************/